Skip to content

Commit 7c77163

Browse files
bondhugulabondhugula
committed
[MLIR][NFC] drop unnecessary matches in affine dma generate test case
 Drop unnecessary matches in affine DMA generate test case. Subscribers: mehdi_amini, rriddle, jpienaar, burmako, shauheen, antiagainst, nicolasvasilache, arpith-jacob, mgester, lucyrfox, liufengdb, Joonsoo, grosul1, llvm-commits Tags: #llvm Differential Revision: https://reviews.llvm.org/D77243
1 parent 5e80931 commit 7c77163

File tree

1 file changed

+68
-68
lines changed

1 file changed

+68
-68
lines changed

‎mlir/test/Dialect/Affine/dma-generate.mlir

Lines changed: 68 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -22,28 +22,28 @@ func @loop_nest_1d() {
2222
%B = alloc() : memref<512 x f32>
2323
%F = alloc() : memref<256 x f32, 2>
2424
// First DMA buffer.
25-
// CHECK: %{{.*}} = alloc() : memref<256xf32>
26-
// CHECK: %{{.*}} = alloc() : memref<256xf32, 2>
25+
// CHECK: alloc() : memref<256xf32>
26+
// CHECK: alloc() : memref<256xf32, 2>
2727
// Tag for first DMA.
28-
// CHECK: %{{.*}} = alloc() : memref<1xi32>
28+
// CHECK: alloc() : memref<1xi32>
2929
// First DMA transfer.
3030
// CHECK: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<256xf32, 2>, memref<1xi32>
3131
// CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
3232
// Second DMA buffer.
33-
// CHECK: %{{.*}} = alloc() : memref<256xf32, 2>
33+
// CHECK: alloc() : memref<256xf32, 2>
3434
// Tag for second DMA.
35-
// CHECK: %{{.*}} = alloc() : memref<1xi32>
35+
// CHECK: alloc() : memref<1xi32>
3636
// Second DMA transfer.
3737
// CHECK: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<512xf32>, memref<256xf32, 2>, memref<1xi32>
3838
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
3939
// CHECK: affine.for %{{.*}} = 0 to 256 {
40-
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
41-
// CHECK: %{{.*}} = affine.apply [[MAP_PLUS_256]](%{{.*}})
40+
// CHECK-NEXT: affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
41+
// CHECK: affine.apply [[MAP_PLUS_256]](%{{.*}})
4242
// Buffer for '%{{.*}}' in faster memref space is smaller size: 256xf32
4343
// Affine map for 'affine.load %{{.*}}' is composed: %{{.*}} + 256 - 256 = %{{.*}}.
4444
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
4545
// Already in faster memory space.
46-
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
46+
// CHECK: affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
4747
// CHECK-NEXT: }
4848
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
4949
// CHECK-NEXT: dealloc %{{.*}} : memref<256xf32, 2>
@@ -83,20 +83,20 @@ func @loop_nest_1d() {
8383
// CHECK-NEXT: affine.for %{{.*}} = 0 to 32 {
8484
// CHECK-NEXT: affine.for %{{.*}} = 0 to 32 {
8585
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
86-
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
86+
// CHECK-NEXT: affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
8787
// CHECK-NEXT: %{{.*}} = affine.load [[BUFB]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
8888
// CHECK-NEXT: "foo"(%{{.*}}) : (f32) -> ()
8989
// CHECK-NEXT: }
9090
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
91-
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
92-
// CHECK-NEXT: %{{.*}} = affine.load [[BUFA]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
91+
// CHECK-NEXT: affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
92+
// CHECK-NEXT: affine.load [[BUFA]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
9393
// CHECK-NEXT: "bar"(%{{.*}}) : (f32) -> ()
9494
// CHECK-NEXT: }
9595
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
96-
// CHECK-NEXT: %{{.*}} = "abc_compute"() : () -> f32
97-
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
98-
// CHECK-NEXT: %{{.*}} = affine.load [[BUFC]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
99-
// CHECK-NEXT: %{{.*}} = "addf32"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
96+
// CHECK-NEXT: "abc_compute"() : () -> f32
97+
// CHECK-NEXT: affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
98+
// CHECK-NEXT: affine.load [[BUFC]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
99+
// CHECK-NEXT: "addf32"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
100100
// CHECK-NEXT: affine.store %{{.*}}, [[BUFC]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
101101
// CHECK-NEXT: }
102102
// CHECK-NEXT: "foobar"() : () -> ()
@@ -153,11 +153,11 @@ func @loop_nest_high_d(%A: memref<512 x 32 x f32>,
153153
// region within a 256 x 8 memref.
154154
//
155155
// CHECK-LABEL: func @loop_nest_modulo() {
156-
// CHECK: %{{.*}} = alloc() : memref<256x8xf32>
156+
// CHECK: alloc() : memref<256x8xf32>
157157
// CHECK-NEXT: affine.for %{{.*}} = 0 to 32 step 4 {
158-
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}})
159-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1x2xf32, 2>
160-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
158+
// CHECK-NEXT: affine.apply #map{{[0-9]+}}(%{{.*}})
159+
// CHECK-NEXT: alloc() : memref<1x2xf32, 2>
160+
// CHECK-NEXT: alloc() : memref<1xi32>
161161
// Composition of the affine map for '%{{.*}}' causes '%{{.*}}' to be added as a symbol.
162162
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, 0], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256x8xf32>, memref<1x2xf32, 2>, memref<1xi32>
163163
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
@@ -191,16 +191,16 @@ func @loop_nest_tiled() -> memref<256x1024xf32> {
191191
%0 = alloc() : memref<256x1024xf32>
192192
affine.for %i0 = 0 to 256 step 32 {
193193
affine.for %i1 = 0 to 1024 step 32 {
194-
// CHECK: %{{.*}} = alloc() : memref<32x32xf32, 2>
195-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
194+
// CHECK: alloc() : memref<32x32xf32, 2>
195+
// CHECK-NEXT: alloc() : memref<1xi32>
196196
// Strided DMA here: 32 x 32 tile in a 256 x 1024 memref.
197197
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<256x1024xf32>, memref<32x32xf32, 2>, memref<1xi32>
198198
// CHECK-NEXT: affine.dma_wait
199199
// CHECK-NEXT: affine.for %{{.*}} = #map
200200
// CHECK-NEXT: affine.for %{{.*}} = #map
201201
affine.for %i2 = affine_map<(d0) -> (d0)>(%i0) to affine_map<(d0) -> (d0 + 32)>(%i0) {
202202
affine.for %i3 = affine_map<(d0) -> (d0)>(%i1) to affine_map<(d0) -> (d0 + 32)>(%i1) {
203-
// CHECK: %{{.*}} = affine.load %{{.*}}[-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<32x32xf32, 2>
203+
// CHECK: affine.load %{{.*}}[-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<32x32xf32, 2>
204204
%1 = affine.load %0[%i2, %i3] : memref<256x1024xf32>
205205
} // CHECK-NEXT: }
206206
}
@@ -215,14 +215,14 @@ func @loop_nest_tiled() -> memref<256x1024xf32> {
215215
func @dma_constant_dim_access(%A : memref<100x100xf32>) {
216216
%one = constant 1 : index
217217
%N = constant 100 : index
218-
// CHECK: %{{.*}} = alloc() : memref<1x100xf32, 2>
219-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
218+
// CHECK: alloc() : memref<1x100xf32, 2>
219+
// CHECK-NEXT: alloc() : memref<1xi32>
220220
// No strided DMA needed here.
221221
// CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<1x100xf32, 2>,
222222
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
223223
affine.for %i = 0 to 100 {
224224
affine.for %j = 0 to affine_map<()[s0] -> (s0)> ()[%N] {
225-
// CHECK: %{{.*}} = affine.load %{{.*}}[0, %{{.*}}] : memref<1x100xf32, 2>
225+
// CHECK: affine.load %{{.*}}[0, %{{.*}}] : memref<1x100xf32, 2>
226226
affine.load %A[%one, %j] : memref<100 x 100 x f32>
227227
}
228228
}
@@ -243,14 +243,14 @@ func @dma_with_symbolic_accesses(%A : memref<100x100xf32>, %M : index) {
243243
}
244244
}
245245
return
246-
// CHECK: %{{.*}} = alloc() : memref<100x100xf32, 2>
247-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
246+
// CHECK: alloc() : memref<100x100xf32, 2>
247+
// CHECK-NEXT: alloc() : memref<1xi32>
248248
// CHECK-NEXT: affine.dma_start %{{.*}}[0, symbol(%{{.*}}) + 9], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}
249249
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}}
250250
// CHECK-NEXT: affine.for %{{.*}} = 0 to 100 {
251251
// CHECK-NEXT: affine.for %{{.*}} = 0 to 100 {
252-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_SYM_SHIFT]](%{{.*}}, %{{.*}})[%{{.*}}, %{{.*}}]
253-
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<100x100xf32, 2>
252+
// CHECK-NEXT: affine.apply [[MAP_SYM_SHIFT]](%{{.*}}, %{{.*}})[%{{.*}}, %{{.*}}]
253+
// CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<100x100xf32, 2>
254254
// CHECK-NEXT: }
255255
// CHECK-NEXT: }
256256
// CHECK: return
@@ -263,8 +263,8 @@ func @dma_with_symbolic_loop_bounds(%A : memref<100x100xf32>, %M : index, %N: in
263263
%K = constant 9 : index
264264
// The buffer size can't be bound by a constant smaller than the original
265265
// memref size; so the DMA buffer is the entire 100x100.
266-
// CHECK: %{{.*}} = alloc() : memref<100x100xf32, 2>
267-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
266+
// CHECK: alloc() : memref<100x100xf32, 2>
267+
// CHECK-NEXT: alloc() : memref<1xi32>
268268
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
269269
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
270270
affine.for %i = 0 to 100 {
@@ -286,7 +286,7 @@ func @dma_unknown_size(%arg0: memref<?x?xf32>) {
286286
affine.for %j = 0 to %N {
287287
// If this loop nest isn't tiled, the access requires a non-constant DMA
288288
// size -- not yet implemented.
289-
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
289+
// CHECK: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
290290
affine.load %arg0[%i, %j] : memref<? x ? x f32>
291291
// expected-error@-6 {{copy generation failed for one or more memref's in this block}}
292292
}
@@ -306,7 +306,7 @@ func @dma_memref_3d(%arg0: memref<1024x1024x1024xf32>) {
306306
%idz = affine.apply affine_map<(d0) -> (d0 mod 128)>(%k)
307307
// DMA with nested striding (or emulating with loop around strided DMA)
308308
// not yet implemented.
309-
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<1024x1024x1024xf32>
309+
// CHECK: affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<1024x1024x1024xf32>
310310
%v = affine.load %arg0[%idx, %idy, %idz] : memref<1024 x 1024 x 1024 x f32>
311311
// expected-error@-10 {{copy generation failed for one or more memref's in this block}}
312312
}
@@ -351,22 +351,22 @@ func @multi_load_store_union() {
351351
}
352352
return
353353
}
354-
// CHECK: %{{.*}} = alloc() : memref<512x512xf32>
355-
// CHECK-NEXT: %{{.*}} = alloc() : memref<382x446xf32, 2>
356-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
354+
// CHECK: alloc() : memref<512x512xf32>
355+
// CHECK-NEXT: alloc() : memref<382x446xf32, 2>
356+
// CHECK-NEXT: alloc() : memref<1xi32>
357357
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<512x512xf32>, memref<382x446xf32, 2>, memref<1xi32>
358358
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
359-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
359+
// CHECK-NEXT: alloc() : memref<1xi32>
360360
// CHECK-NEXT: affine.for %{{.*}} = 0 to 256 {
361361
// CHECK-NEXT: affine.for %{{.*}} = 0 to 256 {
362-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_64]](%{{.*}})
363-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_128]](%{{.*}})
364-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_2]](%{{.*}})
365-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_2]](%{{.*}})
366-
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}} + 126] : memref<382x446xf32, 2>
367-
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} + 62, %{{.*}}] : memref<382x446xf32, 2>
368-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_128]](%{{.*}})
369-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_192]](%{{.*}})
362+
// CHECK-NEXT: affine.apply [[MAP_PLUS_64]](%{{.*}})
363+
// CHECK-NEXT: affine.apply [[MAP_PLUS_128]](%{{.*}})
364+
// CHECK-NEXT: affine.apply [[MAP_PLUS_2]](%{{.*}})
365+
// CHECK-NEXT: affine.apply [[MAP_PLUS_2]](%{{.*}})
366+
// CHECK-NEXT: affine.load %{{.*}}[%{{.*}}, %{{.*}} + 126] : memref<382x446xf32, 2>
367+
// CHECK-NEXT: affine.load %{{.*}}[%{{.*}} + 62, %{{.*}}] : memref<382x446xf32, 2>
368+
// CHECK-NEXT: affine.apply [[MAP_PLUS_128]](%{{.*}})
369+
// CHECK-NEXT: affine.apply [[MAP_PLUS_192]](%{{.*}})
370370
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}} + 190] : memref<382x446xf32, 2>
371371
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} + 126, %{{.*}}] : memref<382x446xf32, 2>
372372
// CHECK-NEXT: }
@@ -396,29 +396,29 @@ func @dma_loop_straightline_interspersed() {
396396
}
397397
// There are three regions here - the 'load' preceding the loop, the loop
398398
// itself, and the operations appearing after the loop.
399-
// CHECK: %{{.*}} = alloc() : memref<256xf32>
400-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xf32, 2>
401-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
399+
// CHECK: alloc() : memref<256xf32>
400+
// CHECK-NEXT: alloc() : memref<1xf32, 2>
401+
// CHECK-NEXT: alloc() : memref<1xi32>
402402
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<1xf32, 2>, memref<1xi32>
403403
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
404-
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[0] : memref<1xf32, 2>
404+
// CHECK-NEXT: affine.load %{{.*}}[0] : memref<1xf32, 2>
405405
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
406406
// CHECK-NEXT: dealloc %{{.*}} : memref<1xf32, 2>
407-
// CHECK-NEXT: %{{.*}} = alloc() : memref<254xf32, 2>
408-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
407+
// CHECK-NEXT: alloc() : memref<254xf32, 2>
408+
// CHECK-NEXT: alloc() : memref<1xi32>
409409
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<254xf32, 2>, memref<1xi32>
410410
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
411411
// CHECK-NEXT: affine.for %{{.*}} = 1 to 255 {
412-
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} - 1] : memref<254xf32, 2>
412+
// CHECK-NEXT: affine.load %{{.*}}[%{{.*}} - 1] : memref<254xf32, 2>
413413
// CHECK-NEXT: }
414414
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
415415
// CHECK-NEXT: dealloc %{{.*}} : memref<254xf32, 2>
416-
// CHECK-NEXT: %{{.*}} = alloc() : memref<256xf32, 2>
417-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
416+
// CHECK-NEXT: alloc() : memref<256xf32, 2>
417+
// CHECK-NEXT: alloc() : memref<1xi32>
418418
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<256xf32, 2>, memref<1xi32>
419419
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
420-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
421-
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[255] : memref<256xf32, 2>
420+
// CHECK-NEXT: alloc() : memref<1xi32>
421+
// CHECK-NEXT: affine.load %{{.*}}[255] : memref<256xf32, 2>
422422
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[0] : memref<256xf32, 2>
423423
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32, 2>, memref<256xf32>, memref<1xi32>
424424
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
@@ -449,9 +449,9 @@ func @dma_mixed_loop_blocks() {
449449
// CHECK: affine.dma_start [[MEM]][%{{.*}}, %{{.*}}], [[BUF]][%{{.*}}, %{{.*}}], [[TAG]][%{{.*}}], %{{.*}} : memref<256x256xvector<8xf32>>, memref<256x256xvector<8xf32>, 2>, memref<1xi32>
450450
// CHECK-NEXT: affine.dma_wait [[TAG]][%{{.*}}], %{{.*}} : memref<1xi32>
451451
// CHECK-NEXT: affine.for %{{.*}} = 0 to 256 {
452-
// CHECK: %{{.*}} = affine.load [[BUF]][0, 0] : memref<256x256xvector<8xf32>, 2>
452+
// CHECK: affine.load [[BUF]][0, 0] : memref<256x256xvector<8xf32>, 2>
453453
// CHECK: affine.for %{{.*}} = 0 to 256 {
454-
// CHECK-NEXT: %{{.*}} = affine.load [[BUF]][%{{.*}}, %{{.*}}] : memref<256x256xvector<8xf32>, 2>
454+
// CHECK-NEXT: affine.load [[BUF]][%{{.*}}, %{{.*}}] : memref<256x256xvector<8xf32>, 2>
455455

456456
// -----
457457

@@ -469,7 +469,7 @@ func @relative_loop_bounds(%arg0: memref<1027xf32>) {
469469
// CHECK-NEXT: [[MEM:%[0-9]+]] = alloc() : memref<1xi32>
470470
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
471471
// CHECK-NEXT: affine.for %{{.*}} = {{#map[0-9]+}}(%{{.*}}) to {{#map[0-9]+}}(%{{.*}}) {
472-
// CHECK-NEXT: %{{.*}} = constant 0.000000e+00 : f32
472+
// CHECK-NEXT: constant 0.000000e+00 : f32
473473
// CHECK-NEXT: affine.store %{{.*}}, [[BUF]][%{{.*}}] : memref<1027xf32, 2>
474474
// CHECK-NEXT: }
475475
// CHECK-NEXT: }
@@ -496,16 +496,16 @@ func @test_read_write_region_union() {
496496
return
497497
}
498498

499-
// CHECK: %{{.*}} = alloc() : memref<256xf32>
500-
// CHECK-NEXT: %{{.*}} = alloc() : memref<85xf32, 2>
501-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
499+
// CHECK: alloc() : memref<256xf32>
500+
// CHECK-NEXT: alloc() : memref<85xf32, 2>
501+
// CHECK-NEXT: alloc() : memref<1xi32>
502502
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<85xf32, 2>, memref<1xi32>
503503
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
504-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
504+
// CHECK-NEXT: alloc() : memref<1xi32>
505505
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
506-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_READ_OFFSET]](%{{.*}})
507-
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_WRITE_OFFSET]](%{{.*}})
508-
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} + 75] : memref<85xf32, 2>
506+
// CHECK-NEXT: affine.apply [[MAP_READ_OFFSET]](%{{.*}})
507+
// CHECK-NEXT: affine.apply [[MAP_WRITE_OFFSET]](%{{.*}})
508+
// CHECK-NEXT: affine.load %{{.*}}[%{{.*}} + 75] : memref<85xf32, 2>
509509
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<85xf32, 2>
510510
// CHECK-NEXT: }
511511
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<85xf32, 2>, memref<256xf32>, memref<1xi32>
@@ -567,8 +567,8 @@ func @test_memref_bounds(%arg0: memref<4x4x16x1xvector<8x128xf32>>, %arg1: memre
567567
return %arg1, %arg2 : memref<144x9xvector<8x128xf32>>, memref<2xvector<8x128xf32>>
568568
}
569569

570-
// CHECK: %{{.*}} = alloc() : memref<4x4x16x1xvector<8x128xf32>, 2>
571-
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
570+
// CHECK: alloc() : memref<4x4x16x1xvector<8x128xf32>, 2>
571+
// CHECK-NEXT: alloc() : memref<1xi32>
572572
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<4x4x16x1xvector<8x128xf32>>, memref<4x4x16x1xvector<8x128xf32>, 2>, memref<1xi32>
573573
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
574574

0 commit comments

Comments
 (0)