Standardize the value numbering in the AsmPrinter.

Change the AsmPrinter to number values breadth-first so that values in adjacent regions can have the same name. This allows for ModuleOp to contain operations that produce results. This also standardizes the special name of region entry arguments to "arg[0-9+]" now that Functions are also operations.

PiperOrigin-RevId: 257225069

12 files changed, 228 insertions, 228 deletions

diff --git a/mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir b/mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir
index 5ac4a01fb8a..5d8acead7a1 100644
--- a/mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir
+++ b/mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir
@@ -51,18 +51,18 @@ func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %d
   return
 }
 
-// CHECK-LABEL: func @materialize_read(%arg0: index, %arg1: index, %arg2: index, %arg3: index) {
+// CHECK-LABEL: func @materialize_read(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
   // CHECK-NEXT:  %[[C0:.*]] = constant 0 : index
-  // CHECK-NEXT:  %0 = alloc(%arg0, %arg1, %arg2, %arg3) : memref<?x?x?x?xf32>
-  // CHECK-NEXT:  affine.for %[[I0:.*]] = 0 to %arg0 step 3 {
-  // CHECK-NEXT:    affine.for %[[I1:.*]] = 0 to %arg1 {
-  // CHECK-NEXT:      affine.for %[[I2:.*]] = 0 to %arg2 {
-  // CHECK-NEXT:        affine.for %[[I3:.*]] = 0 to %arg3 step 5 {
-  //      CHECK:          %[[D0:.*]] = dim %0, 0 : memref<?x?x?x?xf32>
-  // CHECK-NEXT:          %[[D1:.*]] = dim %0, 1 : memref<?x?x?x?xf32>
-  // CHECK-NEXT:          %[[D2:.*]] = dim %0, 2 : memref<?x?x?x?xf32>
-  // CHECK-NEXT:          %[[D3:.*]] = dim %0, 3 : memref<?x?x?x?xf32>
+  // CHECK-NEXT:  %{{.*}} = alloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?x?xf32>
+  // CHECK-NEXT:  affine.for %[[I0:.*]] = 0 to %{{.*}} step 3 {
+  // CHECK-NEXT:    affine.for %[[I1:.*]] = 0 to %{{.*}} {
+  // CHECK-NEXT:      affine.for %[[I2:.*]] = 0 to %{{.*}} {
+  // CHECK-NEXT:        affine.for %[[I3:.*]] = 0 to %{{.*}} step 5 {
+  //      CHECK:          %[[D0:.*]] = dim %{{.*}}, 0 : memref<?x?x?x?xf32>
+  // CHECK-NEXT:          %[[D1:.*]] = dim %{{.*}}, 1 : memref<?x?x?x?xf32>
+  // CHECK-NEXT:          %[[D2:.*]] = dim %{{.*}}, 2 : memref<?x?x?x?xf32>
+  // CHECK-NEXT:          %[[D3:.*]] = dim %{{.*}}, 3 : memref<?x?x?x?xf32>
   //      CHECK:          %[[ALLOC:.*]] = alloc() : memref<5x4x3xf32>
   // CHECK-NEXT:          %[[VECTOR_VIEW:.*]] = vector.type_cast %[[ALLOC]] : memref<5x4x3xf32>, memref<1xvector<5x4x3xf32>>
   // CHECK-NEXT:          affine.for %[[I4:.*]] = 0 to 3 {
@@ -94,7 +94,7 @@ func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
   // CHECK-NEXT:                {{.*}} = cmpi "slt", {{.*}}, %[[C0]] : index
   // CHECK-NEXT:                %[[L3:.*]] = select
   //
-  // CHECK-NEXT:                {{.*}} = load %0[%[[L0]], %[[L1]], %[[L2]], %[[L3]]] : memref<?x?x?x?xf32>
+  // CHECK-NEXT:                {{.*}} = load %{{.*}}[%[[L0]], %[[L1]], %[[L2]], %[[L3]]] : memref<?x?x?x?xf32>
   // CHECK-NEXT:                store {{.*}}, %[[ALLOC]][%[[I6]], %[[I5]], %[[I4]]] : memref<5x4x3xf32>
   // CHECK-NEXT:              }
   // CHECK-NEXT:            }
@@ -124,22 +124,22 @@ func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
   return
 }
 
-// CHECK-LABEL:func @materialize_write(%arg0: index, %arg1: index, %arg2: index, %arg3: index) {
+// CHECK-LABEL:func @materialize_write(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
 func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
-  // CHECK-NEXT:  %cst = constant dense<1.000000e+00> : vector<5x4x3xf32>
+  // CHECK-NEXT:  %{{.*}} = constant dense<1.000000e+00> : vector<5x4x3xf32>
   // CHECK-NEXT:  %[[C0:.*]] = constant 0 : index
-  // CHECK-NEXT:  %0 = alloc(%arg0, %arg1, %arg2, %arg3) : memref<?x?x?x?xf32>
-  // CHECK-NEXT:  affine.for %[[I0:.*]] = 0 to %arg0 step 3 {
-  // CHECK-NEXT:    affine.for %[[I1:.*]] = 0 to %arg1 step 4 {
-  // CHECK-NEXT:      affine.for %[[I2:.*]] = 0 to %arg2 {
-  // CHECK-NEXT:        affine.for %[[I3:.*]] = 0 to %arg3 step 5 {
-  //      CHECK:          %[[D0:.*]] = dim %0, 0 : memref<?x?x?x?xf32>
-  // CHECK-NEXT:          %[[D1:.*]] = dim %0, 1 : memref<?x?x?x?xf32>
-  // CHECK-NEXT:          %[[D2:.*]] = dim %0, 2 : memref<?x?x?x?xf32>
-  // CHECK-NEXT:          %[[D3:.*]] = dim %0, 3 : memref<?x?x?x?xf32>
+  // CHECK-NEXT:  %{{.*}} = alloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?x?xf32>
+  // CHECK-NEXT:  affine.for %[[I0:.*]] = 0 to %{{.*}} step 3 {
+  // CHECK-NEXT:    affine.for %[[I1:.*]] = 0 to %{{.*}} step 4 {
+  // CHECK-NEXT:      affine.for %[[I2:.*]] = 0 to %{{.*}} {
+  // CHECK-NEXT:        affine.for %[[I3:.*]] = 0 to %{{.*}} step 5 {
+  //      CHECK:          %[[D0:.*]] = dim %{{.*}}, 0 : memref<?x?x?x?xf32>
+  // CHECK-NEXT:          %[[D1:.*]] = dim %{{.*}}, 1 : memref<?x?x?x?xf32>
+  // CHECK-NEXT:          %[[D2:.*]] = dim %{{.*}}, 2 : memref<?x?x?x?xf32>
+  // CHECK-NEXT:          %[[D3:.*]] = dim %{{.*}}, 3 : memref<?x?x?x?xf32>
   // CHECK:               %[[ALLOC:.*]] = alloc() : memref<5x4x3xf32>
   // CHECK-NEXT:          %[[VECTOR_VIEW:.*]] = vector.type_cast {{.*}} : memref<5x4x3xf32>, memref<1xvector<5x4x3xf32>>
-  //      CHECK:          store %cst, {{.*}} : memref<1xvector<5x4x3xf32>>
+  //      CHECK:          store %{{.*}}, {{.*}} : memref<1xvector<5x4x3xf32>>
   // CHECK-NEXT:          affine.for %[[I4:.*]] = 0 to 3 {
   // CHECK-NEXT:            affine.for %[[I5:.*]] = 0 to 4 {
   // CHECK-NEXT:              affine.for %[[I6:.*]] = 0 to 5 {
@@ -158,7 +158,7 @@ func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
   // CHECK-NEXT:                %[[S1:.*]] = select {{.*}}, %[[C0]], {{.*}} : index
   //
   // CHECK-NEXT:                {{.*}} = affine.apply #[[SUB]]()[%[[D2]]]
-  // CHECK-NEXT:                {{.*}} = cmpi "slt", %[[I2]], %3 : index
+  // CHECK-NEXT:                {{.*}} = cmpi "slt", %[[I2]], %{{.*}} : index
   // CHECK-NEXT:                {{.*}} = select {{.*}}, %[[I2]], {{.*}} : index
   // CHECK-NEXT:                {{.*}} = cmpi "slt", %[[I2]], %[[C0]] : index
   // CHECK-NEXT:                %[[S2:.*]] = select {{.*}}, %[[C0]], {{.*}} : index
diff --git a/mlir/test/Transforms/Vectorize/materialize.mlir b/mlir/test/Transforms/Vectorize/materialize.mlir
index ac44e475925..dbd975bb169 100644
--- a/mlir/test/Transforms/Vectorize/materialize.mlir
+++ b/mlir/test/Transforms/Vectorize/materialize.mlir
@@ -10,21 +10,21 @@
 func @materialize(%M : index, %N : index, %O : index, %P : index) {
   %A = alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
   %f1 = constant dense<1.000000e+00> : vector<4x4x4xf32>
-  // CHECK:  affine.for %i0 = 0 to %arg0 step 4 {
-  // CHECK-NEXT:    affine.for %i1 = 0 to %arg1 step 4 {
-  // CHECK-NEXT:      affine.for %i2 = 0 to %arg2 {
-  // CHECK-NEXT:        affine.for %i3 = 0 to %arg3 step 4 {
-  // CHECK-NEXT:          %[[a:[0-9]+]] = {{.*}}[[ID1]](%i0)
-  // CHECK-NEXT:          %[[b:[0-9]+]] = {{.*}}[[ID1]](%i1)
-  // CHECK-NEXT:          %[[c:[0-9]+]] = {{.*}}[[ID1]](%i2)
-  // CHECK-NEXT:          %[[d:[0-9]+]] = {{.*}}[[ID1]](%i3)
-  // CHECK-NEXT:          vector.transfer_write {{.*}}, %0[%[[a]], %[[b]], %[[c]], %[[d]]] {permutation_map = #[[D0D1D2D3TOD1D0]]} : vector<4x4xf32>, memref<?x?x?x?xf32>
-  // CHECK:          %[[b1:[0-9]+]] = {{.*}}[[D0P1]](%i1)
-  // CHECK:          vector.transfer_write {{.*}}, %0[{{.*}}, %[[b1]], {{.*}}] {permutation_map = #[[D0D1D2D3TOD1D0]]} : vector<4x4xf32>, memref<?x?x?x?xf32>
-  // CHECK:          %[[b2:[0-9]+]] = {{.*}}[[D0P2]](%i1)
-  // CHECK:          vector.transfer_write {{.*}}, %0[{{.*}}, %[[b2]], {{.*}}] {permutation_map = #[[D0D1D2D3TOD1D0]]} : vector<4x4xf32>, memref<?x?x?x?xf32>
-  // CHECK:          %[[b3:[0-9]+]] = {{.*}}[[D0P3]](%i1)
-  // CHECK:          vector.transfer_write {{.*}}, %0[{{.*}}, %[[b3]], {{.*}}] {permutation_map = #[[D0D1D2D3TOD1D0]]} : vector<4x4xf32>, memref<?x?x?x?xf32>
+  // CHECK:  affine.for %{{.*}} = 0 to %{{.*}} step 4 {
+  // CHECK-NEXT:    affine.for %{{.*}} = 0 to %{{.*}} step 4 {
+  // CHECK-NEXT:      affine.for %{{.*}} = 0 to %{{.*}} {
+  // CHECK-NEXT:        affine.for %{{.*}} = 0 to %{{.*}} step 4 {
+  // CHECK-NEXT:          %[[a:[0-9]+]] = {{.*}}[[ID1]](%{{.*}})
+  // CHECK-NEXT:          %[[b:[0-9]+]] = {{.*}}[[ID1]](%{{.*}})
+  // CHECK-NEXT:          %[[c:[0-9]+]] = {{.*}}[[ID1]](%{{.*}})
+  // CHECK-NEXT:          %[[d:[0-9]+]] = {{.*}}[[ID1]](%{{.*}})
+  // CHECK-NEXT:          vector.transfer_write {{.*}}, %{{.*}}[%[[a]], %[[b]], %[[c]], %[[d]]] {permutation_map = #[[D0D1D2D3TOD1D0]]} : vector<4x4xf32>, memref<?x?x?x?xf32>
+  // CHECK:          %[[b1:[0-9]+]] = {{.*}}[[D0P1]](%{{.*}})
+  // CHECK:          vector.transfer_write {{.*}}, %{{.*}}[{{.*}}, %[[b1]], {{.*}}] {permutation_map = #[[D0D1D2D3TOD1D0]]} : vector<4x4xf32>, memref<?x?x?x?xf32>
+  // CHECK:          %[[b2:[0-9]+]] = {{.*}}[[D0P2]](%{{.*}})
+  // CHECK:          vector.transfer_write {{.*}}, %{{.*}}[{{.*}}, %[[b2]], {{.*}}] {permutation_map = #[[D0D1D2D3TOD1D0]]} : vector<4x4xf32>, memref<?x?x?x?xf32>
+  // CHECK:          %[[b3:[0-9]+]] = {{.*}}[[D0P3]](%{{.*}})
+  // CHECK:          vector.transfer_write {{.*}}, %{{.*}}[{{.*}}, %[[b3]], {{.*}}] {permutation_map = #[[D0D1D2D3TOD1D0]]} : vector<4x4xf32>, memref<?x?x?x?xf32>
   affine.for %i0 = 0 to %M step 4 {
     affine.for %i1 = 0 to %N step 4 {
       affine.for %i2 = 0 to %O {
diff --git a/mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir b/mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir
index 88a62eab0b9..055b43b0dfe 100644
--- a/mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir
+++ b/mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir
@@ -15,8 +15,8 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   %f1 = constant 1.0 : f32
   %f2 = constant 2.0 : f32
   // 4x unroll (jammed by construction).
-  // CHECK: affine.for %i0 = 0 to %arg0 {
-  // CHECK-NEXT:   affine.for %i1 = 0 to %arg1 step 32 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 32 {
   // CHECK-NEXT:     %[[CST0:.*]] = constant dense<1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     %[[CST1:.*]] = constant dense<1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     %[[CST2:.*]] = constant dense<1.000000e+00> : vector<8xf32>
@@ -41,8 +41,8 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
     }
   }
   // 4x unroll (jammed by construction).
-  // CHECK: affine.for %i2 = 0 to %arg0 {
-  // CHECK-NEXT:   affine.for %i3 = 0 to %arg1 step 32 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 32 {
   // CHECK-NEXT:     %[[CST0:.*]] = constant dense<2.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     %[[CST1:.*]] = constant dense<2.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     %[[CST2:.*]] = constant dense<2.000000e+00> : vector<8xf32>
@@ -67,8 +67,8 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
     }
   }
   // 4x unroll (jammed by construction).
-  // CHECK: affine.for %i4 = 0 to %arg0 {
-  // CHECK-NEXT:   affine.for %i5 = 0 to %arg1 step 32 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 32 {
   // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector.transfer_read
diff --git a/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir b/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir
index 93e42ecfbc7..882f5e6fcbe 100644
--- a/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir
+++ b/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir
@@ -15,52 +15,52 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   %f1 = constant 1.0 : f32
   %f2 = constant 2.0 : f32
   // (3x2)x unroll (jammed by construction).
-  // CHECK: affine.for %i0 = 0 to %arg0 step 3 {
-  // CHECK-NEXT:   affine.for %i1 = 0 to %arg1 step 16 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 3 {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 16 {
   // CHECK-NEXT:     {{.*}} = constant dense<1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = constant dense<1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = constant dense<1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = constant dense<1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = constant dense<1.000000e+00> : vector<8xf32>
   // CHECK-NEXT:     {{.*}} = constant dense<1.000000e+00> : vector<8xf32>
-  // CHECK-NEXT:     %[[VAL00:.*]] = affine.apply [[ID1]](%i0)
-  // CHECK-NEXT:     %[[VAL01:.*]] = affine.apply [[ID1]](%i1)
+  // CHECK-NEXT:     %[[VAL00:.*]] = affine.apply [[ID1]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL01:.*]] = affine.apply [[ID1]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL00]], %[[VAL01]]] {permutation_map = [[D0D1TOD1]]} : vector<8xf32>, memref<?x?xf32>
-  // CHECK-NEXT:     %[[VAL10:.*]] = affine.apply [[ID1]](%i0)
-  // CHECK-NEXT:     %[[VAL11:.*]] = affine.apply [[D0P8]](%i1)
+  // CHECK-NEXT:     %[[VAL10:.*]] = affine.apply [[ID1]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL11:.*]] = affine.apply [[D0P8]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL10]], %[[VAL11]]] {permutation_map = [[D0D1TOD1]]} : vector<8xf32>, memref<?x?xf32>
-  // CHECK-NEXT:     %[[VAL20:.*]] = affine.apply [[D0P1]](%i0)
-  // CHECK-NEXT:     %[[VAL21:.*]] = affine.apply [[ID1]](%i1)
+  // CHECK-NEXT:     %[[VAL20:.*]] = affine.apply [[D0P1]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL21:.*]] = affine.apply [[ID1]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL20]], %[[VAL21]]] {permutation_map = [[D0D1TOD1]]} : vector<8xf32>, memref<?x?xf32>
-  // CHECK-NEXT:     %[[VAL30:.*]] = affine.apply [[D0P1]](%i0)
-  // CHECK-NEXT:     %[[VAL31:.*]] = affine.apply [[D0P8]](%i1)
+  // CHECK-NEXT:     %[[VAL30:.*]] = affine.apply [[D0P1]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL31:.*]] = affine.apply [[D0P8]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL30]], %[[VAL31]]] {permutation_map = [[D0D1TOD1]]} : vector<8xf32>, memref<?x?xf32>
-  // CHECK-NEXT:     %[[VAL40:.*]] = affine.apply [[D0P2]](%i0)
-  // CHECK-NEXT:     %[[VAL41:.*]] = affine.apply [[ID1]](%i1)
+  // CHECK-NEXT:     %[[VAL40:.*]] = affine.apply [[D0P2]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL41:.*]] = affine.apply [[ID1]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL40]], %[[VAL41]]] {permutation_map = [[D0D1TOD1]]} : vector<8xf32>, memref<?x?xf32>
-  // CHECK-NEXT:     %[[VAL50:.*]] = affine.apply [[D0P2]](%i0)
-  // CHECK-NEXT:     %[[VAL51:.*]] = affine.apply [[D0P8]](%i1)
+  // CHECK-NEXT:     %[[VAL50:.*]] = affine.apply [[D0P2]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL51:.*]] = affine.apply [[D0P8]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL50]], %[[VAL51]]] {permutation_map = [[D0D1TOD1]]} : vector<8xf32>, memref<?x?xf32>
   affine.for %i0 = 0 to %M {
     affine.for %i1 = 0 to %N {
-      // non-scoped %f1
+      // non-scoped %{{.*}}
       affine.store %f1, %A[%i0, %i1] : memref<?x?xf32, 0>
     }
   }
   // (3x2)x unroll (jammed by construction).
-  // CHECK: affine.for %i2 = 0 to %arg0 step 3 {
-  // CHECK-NEXT:   affine.for %i3 = 0 to %arg1 step 16 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 3 {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 16 {
   // .....
   affine.for %i2 = 0 to %M {
     affine.for %i3 = 0 to %N {
-      // non-scoped %f2
+      // non-scoped %{{.*}}
       // CHECK does (3x4)x unrolling.
       affine.store %f2, %B[%i2, %i3] : memref<?x?xf32, 0>
     }
   }
   // (3x2)x unroll (jammed by construction).
-  // CHECK: affine.for %i4 = 0 to %arg0 step 3 {
-  // CHECK-NEXT:   affine.for %i5 = 0 to %arg1 step 16 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 3 {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 16 {
   // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector.transfer_read
diff --git a/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir b/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir
index ad6452f349c..abf465284be 100644
--- a/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir
+++ b/mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir
@@ -13,44 +13,44 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   %f1 = constant 1.0 : f32
   %f2 = constant 2.0 : f32
   // 2x unroll (jammed by construction).
-  // CHECK: affine.for %i0 = 0 to %arg0 step 3 {
-  // CHECK-NEXT:   affine.for %i1 = 0 to %arg1 step 32 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 3 {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 32 {
   // CHECK-NEXT:     {{.*}} = constant dense<1.000000e+00> : vector<3x16xf32>
   // CHECK-NEXT:     {{.*}} = constant dense<1.000000e+00> : vector<3x16xf32>
-  // CHECK-NEXT:     %[[VAL00:.*]] = affine.apply [[ID1]](%i0)
-  // CHECK-NEXT:     %[[VAL01:.*]] = affine.apply [[ID1]](%i1)
+  // CHECK-NEXT:     %[[VAL00:.*]] = affine.apply [[ID1]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL01:.*]] = affine.apply [[ID1]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL00]], %[[VAL01]]] {permutation_map = [[ID2]]} : vector<3x16xf32>, memref<?x?xf32>
-  // CHECK-NEXT:     %[[VAL10:.*]] = affine.apply [[ID1]](%i0)
-  // CHECK-NEXT:     %[[VAL11:.*]] = affine.apply [[D0P16]](%i1)
+  // CHECK-NEXT:     %[[VAL10:.*]] = affine.apply [[ID1]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL11:.*]] = affine.apply [[D0P16]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL10]], %[[VAL11]]] {permutation_map = [[ID2]]} : vector<3x16xf32>, memref<?x?xf32>
   //
   affine.for %i0 = 0 to %M {
     affine.for %i1 = 0 to %N {
-      // non-scoped %f1
+      // non-scoped %{{.*}}
       affine.store %f1, %A[%i0, %i1] : memref<?x?xf32, 0>
     }
   }
   // 2x unroll (jammed by construction).
-  // CHECK: affine.for %i2 = 0 to %arg0 step 3 {
-  // CHECK-NEXT:   affine.for %i3 = 0 to %arg1 step 32 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 3 {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 32 {
   // CHECK-NEXT:     {{.*}} = constant dense<2.000000e+00> : vector<3x16xf32>
   // CHECK-NEXT:     {{.*}} = constant dense<2.000000e+00> : vector<3x16xf32>
-  // CHECK-NEXT:     %[[VAL00:.*]] = affine.apply [[ID1]](%i2)
-  // CHECK-NEXT:     %[[VAL01:.*]] = affine.apply [[ID1]](%i3)
+  // CHECK-NEXT:     %[[VAL00:.*]] = affine.apply [[ID1]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL01:.*]] = affine.apply [[ID1]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL00]], %[[VAL01]]] {permutation_map = [[ID2]]} : vector<3x16xf32>, memref<?x?xf32>
-  // CHECK-NEXT:     %[[VAL10:.*]] = affine.apply [[ID1]](%i2)
-  // CHECK-NEXT:     %[[VAL11:.*]] = affine.apply [[D0P16]](%i3)
+  // CHECK-NEXT:     %[[VAL10:.*]] = affine.apply [[ID1]](%{{.*}})
+  // CHECK-NEXT:     %[[VAL11:.*]] = affine.apply [[D0P16]](%{{.*}})
   // CHECK-NEXT:     vector.transfer_write {{.*}}, {{.*}}[%[[VAL10]], %[[VAL11]]] {permutation_map = [[ID2]]} : vector<3x16xf32>, memref<?x?xf32>
   //
   affine.for %i2 = 0 to %M {
     affine.for %i3 = 0 to %N {
-      // non-scoped %f2
+      // non-scoped %{{.*}}
       affine.store %f2, %B[%i2, %i3] : memref<?x?xf32, 0>
     }
   }
   // 2x unroll (jammed by construction).
-  // CHECK: affine.for %i4 = 0 to %arg0 step 3 {
-  // CHECK-NEXT:   affine.for %i5 = 0 to %arg1 step 32 {
+  // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 3 {
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to %{{.*}} step 32 {
   // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = affine.apply
   // CHECK-NEXT:     {{.*}} = vector.transfer_read
diff --git a/mlir/test/Transforms/Vectorize/normalize_maps.mlir b/mlir/test/Transforms/Vectorize/normalize_maps.mlir
index e7b08b70cce..4854a622642 100644
--- a/mlir/test/Transforms/Vectorize/normalize_maps.mlir
+++ b/mlir/test/Transforms/Vectorize/normalize_maps.mlir
@@ -15,9 +15,9 @@ func @simple() {
     %2 = affine.apply (d0, d1) -> (d0 + d1) (%0, %0)
     %3 = affine.apply (d0, d1) -> (d0 - d1) (%0, %0)
   }
-  // CHECK-NEXT: affine.for %i0 = 0 to 7
-  // CHECK-NEXT:   {{.*}} affine.apply #[[ID1]](%i0)
-  // CHECK-NEXT:   {{.*}} affine.apply #[[D0TIMES2]](%i0)
+  // CHECK-NEXT: affine.for %{{.*}} = 0 to 7
+  // CHECK-NEXT:   {{.*}} affine.apply #[[ID1]](%{{.*}})
+  // CHECK-NEXT:   {{.*}} affine.apply #[[D0TIMES2]](%{{.*}})
   // CHECK-NEXT:   {{.*}} affine.apply #[[ZERO]]()
 
   affine.for %i1 = 0 to 7 {
@@ -29,11 +29,11 @@ func @simple() {
       %24 = affine.apply (d0, d1) -> (-d0 + d1) (%20, %21)
     }
   }
-  //      CHECK: affine.for %i1 = 0 to 7
-  // CHECK-NEXT:   affine.for %i2 = 0 to 42
-  // CHECK-NEXT:     {{.*}} affine.apply #[[D0PLUSD1]](%i1, %i2)
-  // CHECK-NEXT:     {{.*}} affine.apply #[[MINSD0PLUSD1]](%i1, %i2)
-  // CHECK-NEXT:     {{.*}} affine.apply #[[D0MINUSD1]](%i1, %i2)
+  //      CHECK: affine.for %{{.*}} = 0 to 7
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to 42
+  // CHECK-NEXT:     {{.*}} affine.apply #[[D0PLUSD1]](%{{.*}}, %{{.*}})
+  // CHECK-NEXT:     {{.*}} affine.apply #[[MINSD0PLUSD1]](%{{.*}}, %{{.*}})
+  // CHECK-NEXT:     {{.*}} affine.apply #[[D0MINUSD1]](%{{.*}}, %{{.*}})
 
   affine.for %i3 = 0 to 16 {
     affine.for %i4 = 0 to 47 step 2 {
@@ -47,12 +47,12 @@ func @simple() {
       }
     }
   }
-  // CHECK:      affine.for %i3 = 0 to 16
-  // CHECK-NEXT:   affine.for %i4 = 0 to 47 step 2
-  // CHECK-NEXT:     affine.for %i5 = 0 to 78 step 16
-  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%i3)
-  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%i4)
-  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%i5)
+  // CHECK:      affine.for %{{.*}} = 0 to 16
+  // CHECK-NEXT:   affine.for %{{.*}} = 0 to 47 step 2
+  // CHECK-NEXT:     affine.for %{{.*}} = 0 to 78 step 16
+  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%{{.*}})
+  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%{{.*}})
+  // CHECK-NEXT:       {{.*}} affine.apply #[[ID1]](%{{.*}})
 
   return
 }
diff --git a/mlir/test/Transforms/Vectorize/vectorize_1d.mlir b/mlir/test/Transforms/Vectorize/vectorize_1d.mlir
index 48b0ca63661..afab2303c08 100644
--- a/mlir/test/Transforms/Vectorize/vectorize_1d.mlir
+++ b/mlir/test/Transforms/Vectorize/vectorize_1d.mlir
@@ -14,18 +14,18 @@
 // CHECK-LABEL: func @vec1d_1
 func @vec1d_1(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: %[[C0:[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
 // CHECK: for {{.*}} step 128
-// CHECK-NEXT: %3 = affine.apply #map0(%[[C0]])
-// CHECK-NEXT: %4 = affine.apply #map0(%[[C0]])
-// CHECK-NEXT: {{.*}} = vector.transfer_read %arg0[%3, %4] {permutation_map = #[[map_proj_d0d1_0]]} : memref<?x?xf32>, vector<128xf32>
+// CHECK-NEXT: %{{.*}} = affine.apply #map0(%[[C0]])
+// CHECK-NEXT: %{{.*}} = affine.apply #map0(%[[C0]])
+// CHECK-NEXT: {{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1_0]]} : memref<?x?xf32>, vector<128xf32>
    affine.for %i0 = 0 to %M { // vectorized due to scalar -> vector
      %a0 = affine.load %A[%cst0, %cst0] : memref<?x?xf32>
    }
@@ -35,16 +35,16 @@ func @vec1d_1(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec1d_2
 func @vec1d_2(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: %[[C0:[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
 // CHECK:for [[IV3:%[a-zA-Z0-9]+]] = 0 to [[ARG_M]] step 128
-// CHECK-NEXT:   {{.*}} = vector.transfer_read %arg0[%c0, %i0] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
+// CHECK-NEXT:   {{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
    affine.for %i3 = 0 to %M { // vectorized
      %a3 = affine.load %A[%cst0, %i3] : memref<?x?xf32>
    }
@@ -62,11 +62,11 @@ func @vec1d_3(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK:for [[IV8:%[i0-9]+]] = 0 to [[ARG_M]] step 128
-// CHECK-NEXT:   for [[IV9:%[i0-9]*]] = 0 to [[ARG_N]] {
+// CHECK:for [[IV8:%[arg0-9]+]] = 0 to [[ARG_M]] step 128
+// CHECK-NEXT:   for [[IV9:%[arg0-9]*]] = 0 to [[ARG_N]] {
 // CHECK-NEXT:   %[[APP9_0:[0-9]+]] = affine.apply {{.*}}([[IV9]], [[IV8]])
 // CHECK-NEXT:   %[[APP9_1:[0-9]+]] = affine.apply {{.*}}([[IV9]], [[IV8]])
-// CHECK-NEXT:   {{.*}} = vector.transfer_read %arg0[%[[APP9_0]], %[[APP9_1]]] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
+// CHECK-NEXT:   {{.*}} = vector.transfer_read %{{.*}}[%[[APP9_0]], %[[APP9_1]]] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
    affine.for %i8 = 0 to %M { // vectorized
      affine.for %i9 = 0 to %N {
        %a9 = affine.load %A[%i9, %i8 + %i9] : memref<?x?xf32>
@@ -100,8 +100,8 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   }
   affine.for %i4 = 0 to %M {
     affine.for %i5 = 0 to %N {
-      // CHECK: [[A5:%.*]] = vector.transfer_read %0[{{.*}}] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
-      // CHECK: [[B5:%.*]] = vector.transfer_read %1[{{.*}}] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
+      // CHECK: [[A5:%.*]] = vector.transfer_read %{{.*}}[{{.*}}] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
+      // CHECK: [[B5:%.*]] = vector.transfer_read %{{.*}}[{{.*}}] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
       // CHECK: [[S5:%.*]] = addf [[A5]], [[B5]] : vector<128xf32>
       // CHECK: [[SPLAT1:%.*]] = constant dense<1.000000e+00> : vector<128xf32>
       // CHECK: [[S6:%.*]] = addf [[S5]], [[SPLAT1]] : vector<128xf32>
@@ -130,9 +130,9 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
 // CHECK-LABEL: func @vec_rejected_1
 func @vec_rejected_1(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: [[C0:%[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
@@ -148,15 +148,15 @@ func @vec_rejected_1(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_2
 func @vec_rejected_2(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: [[C0:%[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK:   affine.for %i{{[0-9]*}} = 0 to [[ARG_M]] {
+// CHECK:   affine.for %{{.*}}{{[0-9]*}} = 0 to [[ARG_M]] {
    affine.for %i2 = 0 to %M { // not vectorized, would vectorize with --test-fastest-varying=1
      %a2 = affine.load %A[%i2, %cst0] : memref<?x?xf32>
    }
@@ -166,17 +166,17 @@ func @vec_rejected_2(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_3
 func @vec_rejected_3(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: [[C0:%[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK:for [[IV4:%[i0-9]+]] = 0 to [[ARG_M]] step 128 {
-// CHECK-NEXT:   for [[IV5:%[i0-9]*]] = 0 to [[ARG_N]] {
-// CHECK-NEXT:   {{.*}} = vector.transfer_read %arg0[%i1, %i0] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
+// CHECK:for [[IV4:%[arg0-9]+]] = 0 to [[ARG_M]] step 128 {
+// CHECK-NEXT:   for [[IV5:%[arg0-9]*]] = 0 to [[ARG_N]] {
+// CHECK-NEXT:   {{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1_d1]]} : memref<?x?xf32>, vector<128xf32>
    affine.for %i4 = 0 to %M { // vectorized
      affine.for %i5 = 0 to %N { // not vectorized, would vectorize with --test-fastest-varying=1
        %a5 = affine.load %A[%i5, %i4] : memref<?x?xf32>
@@ -188,16 +188,16 @@ func @vec_rejected_3(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_4
 func @vec_rejected_4(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: [[C0:%[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK: for [[IV6:%[i0-9]*]] = 0 to [[ARG_M]] {
-// CHECK-NEXT:   for [[IV7:%[i0-9]*]] = 0 to [[ARG_N]] {
+// CHECK: for [[IV6:%[arg0-9]*]] = 0 to [[ARG_M]] {
+// CHECK-NEXT:   for [[IV7:%[arg0-9]*]] = 0 to [[ARG_N]] {
    affine.for %i6 = 0 to %M { // not vectorized, would vectorize with --test-fastest-varying=1
      affine.for %i7 = 0 to %N { // not vectorized, can never vectorize
        %a7 = affine.load %A[%i6 + %i7, %i6] : memref<?x?xf32>
@@ -209,16 +209,16 @@ func @vec_rejected_4(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_5
 func @vec_rejected_5(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: [[C0:%[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK: for [[IV10:%[i0-9]*]] = 0 to %{{[0-9]*}} {
-// CHECK:   for [[IV11:%[i0-9]*]] = 0 to %{{[0-9]*}} {
+// CHECK: for [[IV10:%[arg0-9]*]] = 0 to %{{[0-9]*}} {
+// CHECK:   for [[IV11:%[arg0-9]*]] = 0 to %{{[0-9]*}} {
    affine.for %i10 = 0 to %M { // not vectorized, need per load transposes
      affine.for %i11 = 0 to %N { // not vectorized, need per load transposes
        %a11 = affine.load %A[%i10, %i11] : memref<?x?xf32>
@@ -231,17 +231,17 @@ func @vec_rejected_5(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_6
 func @vec_rejected_6(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: [[C0:%[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK: for [[IV12:%[i0-9]*]] = 0 to %{{[0-9]*}} {
-// CHECK:   for [[IV13:%[i0-9]*]] = 0 to %{{[0-9]*}} {
-// CHECK:     for [[IV14:%[i0-9]+]] = 0 to [[ARG_P]] step 128
+// CHECK: for [[IV12:%[arg0-9]*]] = 0 to %{{[0-9]*}} {
+// CHECK:   for [[IV13:%[arg0-9]*]] = 0 to %{{[0-9]*}} {
+// CHECK:     for [[IV14:%[arg0-9]+]] = 0 to [[ARG_P]] step 128
    affine.for %i12 = 0 to %M { // not vectorized, can never vectorize
      affine.for %i13 = 0 to %N { // not vectorized, can never vectorize
        affine.for %i14 = 0 to %P { // vectorized
@@ -255,15 +255,15 @@ func @vec_rejected_6(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_7
 func @vec_rejected_7(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: [[C0:%[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK:  affine.for %i{{[0-9]*}} = 0 to %{{[0-9]*}} {
+// CHECK:  affine.for %{{.*}}{{[0-9]*}} = 0 to %{{[0-9]*}} {
    affine.for %i16 = 0 to %M { // not vectorized, can't vectorize a vector load
      %a16 = alloc(%M) : memref<?xvector<2xf32>>
      %l16 = affine.load %a16[%i16] : memref<?xvector<2xf32>>
@@ -274,20 +274,20 @@ func @vec_rejected_7(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_8
 func @vec_rejected_8(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: %[[C0:[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK: affine.for %i{{[0-9]*}} = 0 to %{{[0-9]*}} {
+// CHECK: affine.for %{{.*}}{{[0-9]*}} = 0 to %{{[0-9]*}} {
 // CHECK:   for [[IV18:%[a-zA-Z0-9]+]] = 0 to [[ARG_M]] step 128
-// CHECK:     %3 = affine.apply #map0(%c0)
-// CHECK:     %4 = affine.apply #map0(%c0)
-// CHECK:     {{.*}} = vector.transfer_read %arg0[%3, %4] {permutation_map = #[[map_proj_d0d1_0]]} : memref<?x?xf32>, vector<128xf32>
-   affine.for %i17 = 0 to %M { // not vectorized, the 1-D pattern that matched %i18 in DFS post-order prevents vectorizing %i17
+// CHECK:     %{{.*}} = affine.apply #map0(%{{.*}})
+// CHECK:     %{{.*}} = affine.apply #map0(%{{.*}})
+// CHECK:     {{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1_0]]} : memref<?x?xf32>, vector<128xf32>
+   affine.for %i17 = 0 to %M { // not vectorized, the 1-D pattern that matched %{{.*}} in DFS post-order prevents vectorizing %{{.*}}
      affine.for %i18 = 0 to %M { // vectorized due to scalar -> vector
        %a18 = affine.load %A[%cst0, %cst0] : memref<?x?xf32>
      }
@@ -298,20 +298,20 @@ func @vec_rejected_8(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_9
 func @vec_rejected_9(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: %[[C0:[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK: affine.for %i{{[0-9]*}} = 0 to %{{[0-9]*}} {
+// CHECK: affine.for %{{.*}}{{[0-9]*}} = 0 to %{{[0-9]*}} {
 // CHECK:   for [[IV18:%[a-zA-Z0-9]+]] = 0 to [[ARG_M]] step 128
-// CHECK:      %3 = affine.apply #map0(%c0)
-// CHECK-NEXT: %4 = affine.apply #map0(%c0)
-// CHECK-NEXT: {{.*}} = vector.transfer_read %arg0[%3, %4] {permutation_map = #[[map_proj_d0d1_0]]} : memref<?x?xf32>, vector<128xf32>
-   affine.for %i17 = 0 to %M { // not vectorized, the 1-D pattern that matched %i18 in DFS post-order prevents vectorizing %i17
+// CHECK:      %{{.*}} = affine.apply #map0(%{{.*}})
+// CHECK-NEXT: %{{.*}} = affine.apply #map0(%{{.*}})
+// CHECK-NEXT: {{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1_0]]} : memref<?x?xf32>, vector<128xf32>
+   affine.for %i17 = 0 to %M { // not vectorized, the 1-D pattern that matched %i18 in DFS post-order prevents vectorizing %{{.*}}
      affine.for %i18 = 0 to %M { // vectorized due to scalar -> vector
        %a18 = affine.load %A[%cst0, %cst0] : memref<?x?xf32>
      }
@@ -322,15 +322,15 @@ func @vec_rejected_9(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-LABEL: func @vec_rejected_10
 func @vec_rejected_10(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {
 // CHECK-DAG: [[C0:%[a-z0-9_]+]] = constant 0 : index
-// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %arg0, 0 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %arg0, 1 : memref<?x?xf32>
-// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %arg1, 2 : memref<?x?x?xf32>
+// CHECK-DAG: [[ARG_M:%[0-9]+]] = dim %{{.*}}, 0 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_N:%[0-9]+]] = dim %{{.*}}, 1 : memref<?x?xf32>
+// CHECK-DAG: [[ARG_P:%[0-9]+]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
    %M = dim %A, 0 : memref<?x?xf32>
    %N = dim %A, 1 : memref<?x?xf32>
    %P = dim %B, 2 : memref<?x?x?xf32>
    %cst0 = constant 0 : index
 //
-// CHECK:  affine.for %i{{[0-9]*}} = 0 to %{{[0-9]*}} {
+// CHECK:  affine.for %{{.*}}{{[0-9]*}} = 0 to %{{[0-9]*}} {
    affine.for %i15 = 0 to %M { // not vectorized due to condition below
      affine.if #set0(%i15) {
        %a15 = affine.load %A[%cst0, %cst0] : memref<?x?xf32>
diff --git a/mlir/test/Transforms/Vectorize/vectorize_2d.mlir b/mlir/test/Transforms/Vectorize/vectorize_2d.mlir
index a44dc5446ed..6526d6b757f 100644
--- a/mlir/test/Transforms/Vectorize/vectorize_2d.mlir
+++ b/mlir/test/Transforms/Vectorize/vectorize_2d.mlir
@@ -15,14 +15,14 @@ func @vec2d(%A : memref<?x?x?xf32>) {
    %M = dim %A, 0 : memref<?x?x?xf32>
    %N = dim %A, 1 : memref<?x?x?xf32>
    %P = dim %A, 2 : memref<?x?x?xf32>
-   // CHECK: for  {{.*}} = 0 to %0 {
-   // CHECK:   for {{.*}} = 0 to %1 step 32
-   // CHECK:     for {{.*}} = 0 to %2 step 256
+   // CHECK: for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:   for {{.*}} = 0 to %{{.*}} step 32
+   // CHECK:     for {{.*}} = 0 to %{{.*}} step 256
    // Example:
-   // affine.for %i0 = 0 to %0 {
-   //   affine.for %i1 = 0 to %1 step 32 {
-   //     affine.for %i2 = 0 to %2 step 256 {
-   //       %3 = "vector.transfer_read"(%arg0, %i0, %i1, %i2) : (memref<?x?x?xf32>, index, index, index) -> vector<32x256xf32>
+   // affine.for %{{.*}} = 0 to %{{.*}} {
+   //   affine.for %{{.*}} = 0 to %{{.*}} step 32 {
+   //     affine.for %{{.*}} = 0 to %{{.*}} step 256 {
+   //       %{{.*}} = "vector.transfer_read"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (memref<?x?x?xf32>, index, index, index) -> vector<32x256xf32>
    affine.for %i0 = 0 to %M {
      affine.for %i1 = 0 to %N {
        affine.for %i2 = 0 to %P {
@@ -30,9 +30,9 @@ func @vec2d(%A : memref<?x?x?xf32>) {
        }
      }
    }
-   // CHECK: for  {{.*}} = 0 to %0 {
-   // CHECK:   for  {{.*}} = 0 to %1 {
-   // CHECK:     for  {{.*}} = 0 to %2 {
+   // CHECK: for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:   for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:     for  {{.*}} = 0 to %{{.*}} {
    // For the case: --test-fastest-varying=1 --test-fastest-varying=0 no
    // vectorization happens because of loop nesting order .
    affine.for %i3 = 0 to %M {
@@ -69,8 +69,8 @@ func @vector_add_2d(%M : index, %N : index) -> f32 {
   }
   affine.for %i4 = 0 to %M {
     affine.for %i5 = 0 to %N {
-      // CHECK: [[A5:%.*]] = vector.transfer_read %0[{{.*}}] {permutation_map = #[[map_id2]]} : memref<?x?xf32>, vector<32x256xf32>
-      // CHECK: [[B5:%.*]] = vector.transfer_read %1[{{.*}}] {permutation_map = #[[map_id2]]} : memref<?x?xf32>, vector<32x256xf32>
+      // CHECK: [[A5:%.*]] = vector.transfer_read %{{.*}}[{{.*}}] {permutation_map = #[[map_id2]]} : memref<?x?xf32>, vector<32x256xf32>
+      // CHECK: [[B5:%.*]] = vector.transfer_read %{{.*}}[{{.*}}] {permutation_map = #[[map_id2]]} : memref<?x?xf32>, vector<32x256xf32>
       // CHECK: [[S5:%.*]] = addf [[A5]], [[B5]] : vector<32x256xf32>
       // CHECK: [[SPLAT1:%.*]] = constant dense<1.000000e+00> : vector<32x256xf32>
       // CHECK: [[S6:%.*]] = addf [[S5]], [[SPLAT1]] : vector<32x256xf32>
@@ -104,13 +104,13 @@ func @vectorize_matmul(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: me
   %K = dim %arg0, 1 : memref<?x?xf32>
   %N = dim %arg2, 1 : memref<?x?xf32>
   //      VECT: %[[C0:.*]] = constant 0 : index
-  // VECT-NEXT: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
-  // VECT-NEXT: %[[K:.*]] = dim %arg0, 1 : memref<?x?xf32>
-  // VECT-NEXT: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
+  // VECT-NEXT: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
+  // VECT-NEXT: %[[K:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
+  // VECT-NEXT: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
   //      VECT: {{.*}} #[[map_id1]](%[[M]]) step 4 {
   // VECT-NEXT:   {{.*}} #[[map_id1]](%[[N]]) step 8 {
   //      VECT:     %[[VC0:.*]] = constant dense<0.000000e+00> : vector<4x8xf32>
-  // VECT-NEXT:     vector.transfer_write %[[VC0]], %arg2[%{{.*}}, %{{.*}}] {permutation_map = #[[map_id2]]} : vector<4x8xf32>, memref<?x?xf32>
+  // VECT-NEXT:     vector.transfer_write %[[VC0]], %{{.*}}[%{{.*}}, %{{.*}}] {permutation_map = #[[map_id2]]} : vector<4x8xf32>, memref<?x?xf32>
   affine.for %i0 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%M) {
     affine.for %i1 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%N) {
       %cst = constant 0.000000e+00 : f32
@@ -120,12 +120,12 @@ func @vectorize_matmul(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: me
   //      VECT:  affine.for %[[I2:.*]] = #[[map_id1]](%[[C0]]) to #[[map_id1]](%[[M]]) step 4 {
   // VECT-NEXT:    affine.for %[[I3:.*]] = #[[map_id1]](%[[C0]]) to #[[map_id1]](%[[N]]) step 8 {
   // VECT-NEXT:      affine.for %[[I4:.*]] = #map5(%[[C0]]) to #[[map_id1]](%[[K]]) {
-  // VECT-NEXT:        %[[A:.*]] = vector.transfer_read %arg1[%[[I4]], %[[I3]]] {permutation_map = #[[map_proj_d0d1_zerod1]]} : memref<?x?xf32>, vector<4x8xf32>
-  // VECT-NEXT:        %[[B:.*]] = vector.transfer_read %arg0[%[[I2]], %[[I4]]] {permutation_map = #[[map_proj_d0d1_d0zero]]} : memref<?x?xf32>, vector<4x8xf32>
+  // VECT-NEXT:        %[[A:.*]] = vector.transfer_read %{{.*}}[%[[I4]], %[[I3]]] {permutation_map = #[[map_proj_d0d1_zerod1]]} : memref<?x?xf32>, vector<4x8xf32>
+  // VECT-NEXT:        %[[B:.*]] = vector.transfer_read %{{.*}}[%[[I2]], %[[I4]]] {permutation_map = #[[map_proj_d0d1_d0zero]]} : memref<?x?xf32>, vector<4x8xf32>
   // VECT-NEXT:        %[[C:.*]] = mulf %[[B]], %[[A]] : vector<4x8xf32>
-  // VECT-NEXT:        %[[D:.*]] = vector.transfer_read %arg2[%[[I2]], %[[I3]]] {permutation_map = #[[map_id2]]} : memref<?x?xf32>, vector<4x8xf32>
+  // VECT-NEXT:        %[[D:.*]] = vector.transfer_read %{{.*}}[%[[I2]], %[[I3]]] {permutation_map = #[[map_id2]]} : memref<?x?xf32>, vector<4x8xf32>
   // VECT-NEXT:        %[[E:.*]] = addf %[[D]], %[[C]] : vector<4x8xf32>
-  // VECT-NEXT:        vector.transfer_write %[[E]], %arg2[%[[I2]], %[[I3]]] {permutation_map = #[[map_id2]]} : vector<4x8xf32>, memref<?x?xf32>
+  // VECT-NEXT:        vector.transfer_write %[[E]], %{{.*}}[%[[I2]], %[[I3]]] {permutation_map = #[[map_id2]]} : vector<4x8xf32>, memref<?x?xf32>
   affine.for %i2 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%M) {
     affine.for %i3 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%N) {
       affine.for %i4 = (d0) -> (d0)(%c0) to (d0) -> (d0)(%K) {
diff --git a/mlir/test/Transforms/Vectorize/vectorize_3d.mlir b/mlir/test/Transforms/Vectorize/vectorize_3d.mlir
index 98d8ebccf79..797e58e0d40 100644
--- a/mlir/test/Transforms/Vectorize/vectorize_3d.mlir
+++ b/mlir/test/Transforms/Vectorize/vectorize_3d.mlir
@@ -7,12 +7,12 @@ func @vec3d(%A : memref<?x?x?xf32>) {
    %0 = dim %A, 0 : memref<?x?x?xf32>
    %1 = dim %A, 1 : memref<?x?x?xf32>
    %2 = dim %A, 2 : memref<?x?x?xf32>
-   // CHECK: affine.for %i0 = 0 to %0 {
-   // CHECK:   affine.for %i1 = 0 to %0 {
-   // CHECK:     affine.for %i2 = 0 to %0 step 32 {
-   // CHECK:       affine.for %i3 = 0 to %1 step 64 {
-   // CHECK:         affine.for %i4 = 0 to %2 step 256 {
-   // CHECK:           %3 = vector.transfer_read %arg0[%i2, %i3, %i4] {permutation_map = #[[map_proj_d0d1d2_d0d1d2]]} : memref<?x?x?xf32>, vector<32x64x256xf32>
+   // CHECK: affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} step 32 {
+   // CHECK:       affine.for %{{.*}} = 0 to %{{.*}} step 64 {
+   // CHECK:         affine.for %{{.*}} = 0 to %{{.*}} step 256 {
+   // CHECK:           %{{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d0d1d2]]} : memref<?x?x?xf32>, vector<32x64x256xf32>
    affine.for %t0 = 0 to %0 {
      affine.for %t1 = 0 to %0 {
        affine.for %i0 = 0 to %0 {
diff --git a/mlir/test/Transforms/Vectorize/vectorize_outer_loop_2d.mlir b/mlir/test/Transforms/Vectorize/vectorize_outer_loop_2d.mlir
index b1257d1e4fa..ded8dfad815 100644
--- a/mlir/test/Transforms/Vectorize/vectorize_outer_loop_2d.mlir
+++ b/mlir/test/Transforms/Vectorize/vectorize_outer_loop_2d.mlir
@@ -7,10 +7,10 @@ func @vec2d(%A : memref<?x?x?xf32>) {
    %M = dim %A, 0 : memref<?x?x?xf32>
    %N = dim %A, 1 : memref<?x?x?xf32>
    %P = dim %A, 2 : memref<?x?x?xf32>
-   // CHECK: affine.for %i0 = 0 to %0 step 32
-   // CHECK:   affine.for %i1 = 0 to %1 {
-   // CHECK:     affine.for %i2 = 0 to %2 step 256
-   // CHECK:       {{.*}} = vector.transfer_read %arg0[%i0, %i1, %i2] {permutation_map = #[[map_proj_d0d1d2_d0d2]]} : memref<?x?x?xf32>,  vector<32x256xf32>
+   // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 32
+   // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} step 256
+   // CHECK:       {{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d0d2]]} : memref<?x?x?xf32>,  vector<32x256xf32>
    affine.for %i0 = 0 to %M {
      affine.for %i1 = 0 to %N {
        affine.for %i2 = 0 to %P {
@@ -18,9 +18,9 @@ func @vec2d(%A : memref<?x?x?xf32>) {
        }
      }
    }
-   // CHECK: for  {{.*}} = 0 to %0 {
-   // CHECK:   for  {{.*}} = 0 to %1 {
-   // CHECK:     for  {{.*}} = 0 to %2 {
+   // CHECK: for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:   for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:     for  {{.*}} = 0 to %{{.*}} {
    // For the case: --test-fastest-varying=2 --test-fastest-varying=0 no
    // vectorization happens because of loop nesting order
    affine.for %i3 = 0 to %M {
diff --git a/mlir/test/Transforms/Vectorize/vectorize_outer_loop_transpose_2d.mlir b/mlir/test/Transforms/Vectorize/vectorize_outer_loop_transpose_2d.mlir
index 7d30162e468..36b1a4d4044 100644
--- a/mlir/test/Transforms/Vectorize/vectorize_outer_loop_transpose_2d.mlir
+++ b/mlir/test/Transforms/Vectorize/vectorize_outer_loop_transpose_2d.mlir
@@ -7,9 +7,9 @@ func @vec2d(%A : memref<?x?x?xf32>) {
    %M = dim %A, 0 : memref<?x?x?xf32>
    %N = dim %A, 1 : memref<?x?x?xf32>
    %P = dim %A, 2 : memref<?x?x?xf32>
-   // CHECK: for  {{.*}} = 0 to %0 {
-   // CHECK:   for  {{.*}} = 0 to %1 {
-   // CHECK:     for  {{.*}} = 0 to %2 {
+   // CHECK: for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:   for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:     for  {{.*}} = 0 to %{{.*}} {
    // For the case: --test-fastest-varying=0 --test-fastest-varying=2 no
    // vectorization happens because of loop nesting order.
    affine.for %i0 = 0 to %M {
@@ -19,10 +19,10 @@ func @vec2d(%A : memref<?x?x?xf32>) {
        }
      }
    }
-   // CHECK: affine.for %i3 = 0 to %0 step 32
-   // CHECK:   affine.for %i4 = 0 to %1 step 256
-   // CHECK:     affine.for %i5 = 0 to %2 {
-   // CHECK:       {{.*}} = vector.transfer_read %arg0[%i4, %i5, %i3] {permutation_map = #[[map_proj_d0d1d2_d2d0]]} : memref<?x?x?xf32>, vector<32x256xf32>
+   // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 32
+   // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} step 256
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:       {{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d2d0]]} : memref<?x?x?xf32>, vector<32x256xf32>
    affine.for %i3 = 0 to %M {
      affine.for %i4 = 0 to %N {
        affine.for %i5 = 0 to %P {
@@ -37,15 +37,15 @@ func @vec2d_imperfectly_nested(%A : memref<?x?x?xf32>) {
    %0 = dim %A, 0 : memref<?x?x?xf32>
    %1 = dim %A, 1 : memref<?x?x?xf32>
    %2 = dim %A, 2 : memref<?x?x?xf32>
-   // CHECK: affine.for %i0 = 0 to %0 step 32 {
-   // CHECK:   affine.for %i1 = 0 to %1 {
-   // CHECK:     affine.for %i2 = 0 to %2 step 256 {
-   // CHECK:       %3 = vector.transfer_read %arg0[%i2, %i1, %i0] {permutation_map = #[[map_proj_d0d1d2_d2d0]]} : memref<?x?x?xf32>, vector<32x256xf32>
-   // CHECK:   affine.for %i3 = 0 to %1 step 256 {
-   // CHECK:     affine.for %i4 = 0 to %2 {
-   // CHECK:       %4 = vector.transfer_read %arg0[%i3, %i4, %i0] {permutation_map = #[[map_proj_d0d1d2_d2d0]]} : memref<?x?x?xf32>, vector<32x256xf32>
-   // CHECK:     affine.for %i5 = 0 to %2 {
-   // CHECK:       %5 = vector.transfer_read %arg0[%i3, %i5, %i0] {permutation_map = #[[map_proj_d0d1d2_d2d0]]} : memref<?x?x?xf32>, vector<32x256xf32>
+   // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 32 {
+   // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} step 256 {
+   // CHECK:       %{{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d2d0]]} : memref<?x?x?xf32>, vector<32x256xf32>
+   // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} step 256 {
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:       %{{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d2d0]]} : memref<?x?x?xf32>, vector<32x256xf32>
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:       %{{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d2d0]]} : memref<?x?x?xf32>, vector<32x256xf32>
    affine.for %i0 = 0 to %0 {
      affine.for %i1 = 0 to %1 {
        affine.for %i2 = 0 to %2 {
diff --git a/mlir/test/Transforms/Vectorize/vectorize_transpose_2d.mlir b/mlir/test/Transforms/Vectorize/vectorize_transpose_2d.mlir
index f33e434696e..4f61a26b4a8 100644
--- a/mlir/test/Transforms/Vectorize/vectorize_transpose_2d.mlir
+++ b/mlir/test/Transforms/Vectorize/vectorize_transpose_2d.mlir
@@ -7,9 +7,9 @@ func @vec2d(%A : memref<?x?x?xf32>) {
    %M = dim %A, 0 : memref<?x?x?xf32>
    %N = dim %A, 1 : memref<?x?x?xf32>
    %P = dim %A, 2 : memref<?x?x?xf32>
-   // CHECK: for  {{.*}} = 0 to %0 {
-   // CHECK:   for  {{.*}} = 0 to %1 {
-   // CHECK:     for  {{.*}} = 0 to %2 {
+   // CHECK: for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:   for  {{.*}} = 0 to %{{.*}} {
+   // CHECK:     for  {{.*}} = 0 to %{{.*}} {
    // For the case: --test-fastest-varying=0 --test-fastest-varying=1 no
    // vectorization happens because of loop nesting order.
   affine.for %i0 = 0 to %M {
@@ -19,10 +19,10 @@ func @vec2d(%A : memref<?x?x?xf32>) {
        }
      }
    }
-   // CHECK: affine.for %i3 = 0 to %0 step 32
-   // CHECK:   affine.for %i4 = 0 to %1 {
-   // CHECK:     affine.for %i5 = 0 to %2 step 256
-   // CHECK:       {{.*}} = vector.transfer_read %arg0[%i4, %i5, %i3] {permutation_map = #[[map_proj_d0d1d2_d2d1]]} : memref<?x?x?xf32>, vector<32x256xf32>
+   // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 32
+   // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} step 256
+   // CHECK:       {{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d2d1]]} : memref<?x?x?xf32>, vector<32x256xf32>
    affine.for %i3 = 0 to %M {
      affine.for %i4 = 0 to %N {
        affine.for %i5 = 0 to %P {
@@ -37,15 +37,15 @@ func @vec2d_imperfectly_nested(%A : memref<?x?x?xf32>) {
    %0 = dim %A, 0 : memref<?x?x?xf32>
    %1 = dim %A, 1 : memref<?x?x?xf32>
    %2 = dim %A, 2 : memref<?x?x?xf32>
-   // CHECK: affine.for %i0 = 0 to %0 step 32 {
-   // CHECK:   affine.for %i1 = 0 to %1 step 256 {
-   // CHECK:     affine.for %i2 = 0 to %2 {
-   // CHECK:       %3 = vector.transfer_read %arg0[%i2, %i1, %i0] {permutation_map = #[[map_proj_d0d1d2_d2d1]]} : memref<?x?x?xf32>, vector<32x256xf32>
-   // CHECK:   affine.for %i3 = 0 to %1 {
-   // CHECK:     affine.for %i4 = 0 to %2 step 256 {
-   // CHECK:       %4 = vector.transfer_read %arg0[%i3, %i4, %i0] {permutation_map = #[[map_proj_d0d1d2_d2d1]]} : memref<?x?x?xf32>, vector<32x256xf32>
-   // CHECK:     affine.for %i5 = 0 to %2 step 256 {
-   // CHECK:       %5 = vector.transfer_read %arg0[%i3, %i5, %i0] {permutation_map = #[[map_proj_d0d1d2_d2d1]]} : memref<?x?x?xf32>, vector<32x256xf32>
+   // CHECK: affine.for %{{.*}} = 0 to %{{.*}} step 32 {
+   // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} step 256 {
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:       %{{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d2d1]]} : memref<?x?x?xf32>, vector<32x256xf32>
+   // CHECK:   affine.for %{{.*}} = 0 to %{{.*}} {
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} step 256 {
+   // CHECK:       %{{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d2d1]]} : memref<?x?x?xf32>, vector<32x256xf32>
+   // CHECK:     affine.for %{{.*}} = 0 to %{{.*}} step 256 {
+   // CHECK:       %{{.*}} = vector.transfer_read %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] {permutation_map = #[[map_proj_d0d1d2_d2d1]]} : memref<?x?x?xf32>, vector<32x256xf32>
    affine.for %i0 = 0 to %0 {
      affine.for %i1 = 0 to %1 {
        affine.for %i2 = 0 to %2 {