maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

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
This commit is contained in:
River Riddle 2019-07-09 10:40:29 -07:00 committed by A. Unique TensorFlower
parent 4cabebf04d
commit 89bc449cee
49 changed files with 2609 additions and 2579 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

122
mlir/examples/Linalg/Linalg3/Example.cpp
View File

@ -68,12 +68,12 @@ TEST_FUNC(matmul_as_matvec) {
lowerToFinerGrainedTensorContraction(f);
composeSliceOps(f);
// clang-format off
// CHECK-LABEL: func @matmul_as_matvec(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
// CHECK: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
// CHECK: %[[vA:.*]] = linalg.view %arg0[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: affine.for %i0 = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK: %[[vB:.*]] = linalg.view %arg1[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK: %[[vC:.*]] = linalg.view %arg2[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK-LABEL: func @matmul_as_matvec(%{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>) {
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[vA:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK: %[[vB:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK: %[[vC:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK: linalg.matvec(%[[vA]], %[[vB]], %[[vC]]) : !linalg.view<?xf32>
// clang-format on
cleanupAndPrintFunction(f);
@ -87,14 +87,14 @@ TEST_FUNC(matmul_as_dot) {
lowerToFinerGrainedTensorContraction(f);
composeSliceOps(f);
// clang-format off
// CHECK-LABEL: func @matmul_as_dot(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
// CHECK: affine.for %i0 = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK: %[[vB:.*]] = linalg.view %arg1[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK-NEXT: affine.for %i1 = 0 to (d0) -> (d0)(%[[M]]) {
// CHECK: %[[vA:.*]] = linalg.view %arg0[%{{.*}}, %{{.*}}] : memref<?x?xf32>, index, !linalg.range, !linalg.view<?xf32>
// CHECK-NEXT: %[[vC:.*]] = linalg.view %arg2[%{{.*}}, %{{.*}}] : memref<?x?xf32>, index, index, !linalg.view<f32>
// CHECK-LABEL: func @matmul_as_dot(%{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK: %[[vB:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) {
// CHECK: %[[vA:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, index, !linalg.range, !linalg.view<?xf32>
// CHECK-NEXT: %[[vC:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, index, index, !linalg.view<f32>
// CHECK-NEXT: linalg.dot(%[[vA]], %[[vB]], %[[vC]]) : !linalg.view<f32>
// clang-format on
cleanupAndPrintFunction(f);
@ -107,27 +107,27 @@ TEST_FUNC(matmul_as_loops) {
lowerToLoops(f);
composeSliceOps(f);
// clang-format off
// CHECK-LABEL: func @matmul_as_loops(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %arg0, 1 : memref<?x?xf32>
// CHECK: %[[rM:.*]] = linalg.range %c0:%[[M]]:%c1 : !linalg.range
// CHECK: %[[rN:.*]] = linalg.range %c0:%[[N]]:%c1 : !linalg.range
// CHECK: %[[rK:.*]] = linalg.range %c0:%[[K]]:%c1 : !linalg.range
// CHECK: %[[vA:.*]] = linalg.view %arg0[%[[rM]], %[[rK]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[vB:.*]] = linalg.view %arg1[%[[rK]], %[[rN]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[vC:.*]] = linalg.view %arg2[%[[rM]], %[[rN]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: affine.for %i0 = 0 to (d0) -> (d0)(%[[M]]) {
// CHECK: affine.for %i1 = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK: affine.for %i2 = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK-LABEL: func @matmul_as_loops(%{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[rM:.*]] = linalg.range %{{.*}}:%[[M]]:%{{.*}} : !linalg.range
// CHECK: %[[rN:.*]] = linalg.range %{{.*}}:%[[N]]:%{{.*}} : !linalg.range
// CHECK: %[[rK:.*]] = linalg.range %{{.*}}:%[[K]]:%{{.*}} : !linalg.range
// CHECK: %[[vA:.*]] = linalg.view %{{.*}}[%[[rM]], %[[rK]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[vB:.*]] = linalg.view %{{.*}}[%[[rK]], %[[rN]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[vC:.*]] = linalg.view %{{.*}}[%[[rM]], %[[rN]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) {
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK: %{{.*}} = cmpi "eq", %{{.*}} : index
// CHECK: %{{.*}} = linalg.load %[[vC]][%i0, %i1] : !linalg.view<?x?xf32>
// CHECK: %{{.*}} = linalg.load %[[vC]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK: %{{.*}} = select {{.*}} : f32
// CHECK: %{{.*}} = linalg.load %[[vB]][%i2, %i1] : !linalg.view<?x?xf32>
// CHECK: %{{.*}} = linalg.load %[[vA]][%i0, %i2] : !linalg.view<?x?xf32>
// CHECK: %{{.*}} = linalg.load %[[vB]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK: %{{.*}} = linalg.load %[[vA]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK: %{{.*}} = mulf {{.*}} : f32
// CHECK: %{{.*}} = addf {{.*}} : f32
// CHECK: linalg.store {{.*}}[%i0, %i1] : !linalg.view<?x?xf32>
// CHECK: linalg.store {{.*}}[%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// clang-format on
cleanupAndPrintFunction(f);
}
@ -141,24 +141,24 @@ TEST_FUNC(matmul_as_matvec_as_loops) {
lowerToLoops(f);
composeSliceOps(f);
// clang-format off
// CHECK-LABEL: func @matmul_as_matvec_as_loops(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %arg0, 1 : memref<?x?xf32>
// CHECK: %[[vA:.*]] = linalg.view %arg0[{{.*}}, {{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: affine.for %i0 = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK: %[[vB:.*]] = linalg.view %arg1[{{.*}}, {{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK: %[[vC:.*]] = linalg.view %arg2[{{.*}}, {{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK: affine.for %i1 = 0 to (d0) -> (d0)(%[[M]]) {
// CHECK: affine.for %i2 = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK: %{{.*}} = cmpi "eq", %i2, %{{.*}} : index
// CHECK: %[[C:.*]] = linalg.load %[[vC]][%i1] : !linalg.view<?xf32>
// CHECK-LABEL: func @matmul_as_matvec_as_loops(%{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[vA:.*]] = linalg.view %{{.*}}[{{.*}}, {{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK: %[[vB:.*]] = linalg.view %{{.*}}[{{.*}}, {{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK: %[[vC:.*]] = linalg.view %{{.*}}[{{.*}}, {{.*}}] : memref<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) {
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK: %{{.*}} = cmpi "eq", %{{.*}}, %{{.*}} : index
// CHECK: %[[C:.*]] = linalg.load %[[vC]][%{{.*}}] : !linalg.view<?xf32>
// CHECK: %[[C2:.*]] = select %{{.*}}, %{{.*}}, %[[C]] : f32
// CHECK: %[[B:.*]] = linalg.load %[[vB]][%i2] : !linalg.view<?xf32>
// CHECK: %[[A:.*]] = linalg.load %[[vA]][%i1, %i2] : !linalg.view<?x?xf32>
// CHECK: %[[B:.*]] = linalg.load %[[vB]][%{{.*}}] : !linalg.view<?xf32>
// CHECK: %[[A:.*]] = linalg.load %[[vA]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK: %{{.*}} = mulf %[[A]], %[[B]] : f32
// CHECK: %{{.*}} = addf %[[C2]], %{{.*}} : f32
// CHECK: linalg.store %{{.*}}, %{{.*}}[%i1] : !linalg.view<?xf32>
// CHECK: linalg.store %{{.*}}, %{{.*}}[%{{.*}}] : !linalg.view<?xf32>
// clang-format on
cleanupAndPrintFunction(f);
}
@ -177,24 +177,24 @@ TEST_FUNC(matmul_as_matvec_as_affine) {
cleanupAndPrintFunction(f);
// clang-format off
// CHECK-LABEL: func @matmul_as_matvec_as_affine(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %arg0, 1 : memref<?x?xf32>
// CHECK: affine.for %i0 = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK-LABEL: func @matmul_as_matvec_as_affine(%{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) {
// CHECK-NOT: {{.*}} = linalg.
// CHECK: affine.for %i1 = 0 to (d0) -> (d0)(%[[M]]) {
// CHECK: affine.for %i2 = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK: %3 = cmpi "eq", %i2, %c0 : index
// CHECK: %4 = load %arg2[%i1, %i0] : memref<?x?xf32>
// CHECK: %5 = select %3, %cst, %4 : f32
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) {
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK: %{{.*}} = cmpi "eq", %{{.*}}, %{{.*}} : index
// CHECK: %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : f32
// CHECK-NOT: {{.*}} = linalg.
// CHECK: %6 = load %arg1[%i2, %i0] : memref<?x?xf32>
// CHECK: %7 = load %arg0[%i1, %i2] : memref<?x?xf32>
// CHECK: %8 = mulf %7, %6 : f32
// CHECK: %9 = addf %5, %8 : f32
// CHECK: %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK: %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
// CHECK: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NOT: {{.*}} = linalg.
// CHECK: store %9, %arg2[%i1, %i0] : memref<?x?xf32>
// CHECK: store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// clang-format on
}

102
mlir/examples/Linalg/Linalg4/Example.cpp
View File

@ -73,23 +73,23 @@ TEST_FUNC(matmul_tiled_loops) {
cleanupAndPrintFunction(f);
// clang-format off
// CHECK-LABEL: func @matmul_tiled_loops(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %arg0, 1 : memref<?x?xf32>
// CHECK: affine.for %i0 = 0 to (d0) -> (d0)(%[[M]]) step 8 {
// CHECK: affine.for %i1 = 0 to (d0) -> (d0)(%[[N]]) step 9 {
// CHECK: affine.for %i2 = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK: affine.for %i3 = max (d0)[s0] -> (s0, d0)(%i0)[%{{.*}}] to min (d0)[s0] -> (s0, d0 + 8)(%i0)[%[[M]]] {
// CHECK: affine.for %i4 = max (d0)[s0] -> (s0, d0)(%i1)[%{{.*}}] to min (d0)[s0] -> (s0, d0 + 9)(%i1)[%[[N]]] {
// CHECK-NEXT: %{{.*}} = cmpi "eq", %i2, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = load %arg2[%i3, %i4] : memref<?x?xf32>
// CHECK-LABEL: func @matmul_tiled_loops(%{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) step 8 {
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) step 9 {
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK: affine.for %{{.*}} = max (d0)[s0] -> (s0, d0)(%{{.*}})[%{{.*}}] to min (d0)[s0] -> (s0, d0 + 8)(%{{.*}})[%[[M]]] {
// CHECK: affine.for %{{.*}} = max (d0)[s0] -> (s0, d0)(%{{.*}})[%{{.*}}] to min (d0)[s0] -> (s0, d0 + 9)(%{{.*}})[%[[N]]] {
// CHECK-NEXT: %{{.*}} = cmpi "eq", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = load %arg1[%i2, %i4] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = load %arg0[%i3, %i2] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = mulf %7, %6 : f32
// CHECK-NEXT: %{{.*}} = addf %5, %8 : f32
// CHECK-NEXT: store %{{.*}}, %arg2[%i3, %i4] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// clang-format on
}
@ -103,20 +103,20 @@ TEST_FUNC(matmul_tiled_views) {
composeSliceOps(f);
// clang-format off
// CHECK-LABEL: func @matmul_tiled_views(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %arg0, 1 : memref<?x?xf32>
// CHECK: affine.for %i0 = 0 to (d0) -> (d0)(%[[M]]) step 8 {
// CHECK-NEXT: affine.for %i1 = 0 to (d0) -> (d0)(%[[N]]) step 9 {
// CHECK-NEXT: %[[i0max:.*]] = affine.apply (d0) -> (d0 + 8)(%i0)
// CHECK-NEXT: %[[ri0:.*]] = linalg.range %i0:%[[i0max]]:{{.*}} : !linalg.range
// CHECK-LABEL: func @matmul_tiled_views(%{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) step 8 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) step 9 {
// CHECK-NEXT: %[[i0max:.*]] = affine.apply (d0) -> (d0 + 8)(%{{.*}})
// CHECK-NEXT: %[[ri0:.*]] = linalg.range %{{.*}}:%[[i0max]]:{{.*}} : !linalg.range
// CHECK: %[[rK:.*]] = linalg.range %{{.*}}:%{{.*}}:%{{.*}} : !linalg.range
// CHECK: %[[vA:.*]] = linalg.view %arg0[%[[ri0]], %[[rK]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[i1max:.*]] = affine.apply (d0) -> (d0 + 9)(%i1)
// CHECK-NEXT: %[[ri1:.*]] = linalg.range %i1:%[[i1max]]:%{{.*}} : !linalg.range
// CHECK-NEXT: %[[vB:.*]] = linalg.view %arg1[%7, %9] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: %[[vC:.*]] = linalg.view %arg2[%4, %9] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[vA:.*]] = linalg.view %{{.*}}[%[[ri0]], %[[rK]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[i1max:.*]] = affine.apply (d0) -> (d0 + 9)(%{{.*}})
// CHECK-NEXT: %[[ri1:.*]] = linalg.range %{{.*}}:%[[i1max]]:%{{.*}} : !linalg.range
// CHECK-NEXT: %[[vB:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: %[[vC:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: linalg.matmul(%[[vA]], %[[vB]], %[[vC]]) : !linalg.view<?x?xf32>
// clang-format on
cleanupAndPrintFunction(f);
@ -137,31 +137,31 @@ TEST_FUNC(matmul_tiled_views_as_loops) {
// attack the problem, the best one is an IR change.
// clang-format off
// CHECK-LABEL: func @matmul_tiled_views_as_loops(%arg0: memref<?x?xf32>, %arg1: memref<?x?xf32>, %arg2: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %arg2, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %arg0, 1 : memref<?x?xf32>
// CHECK: affine.for %i0 = 0 to (d0) -> (d0)(%[[M]]) step 8 {
// CHECK-NEXT: affine.for %i1 = 0 to (d0) -> (d0)(%[[N]]) step 9 {
// CHECK-NEXT: %[[i0max:.*]] = affine.apply (d0) -> (d0 + 8)(%i0)
// CHECK-NEXT: %[[ri0:.*]] = linalg.range %i0:%[[i0max]]:{{.*}} : !linalg.range
// CHECK-LABEL: func @matmul_tiled_views_as_loops(%{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>, %{{.*}}: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[K:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) step 8 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) step 9 {
// CHECK-NEXT: %[[i0max:.*]] = affine.apply (d0) -> (d0 + 8)(%{{.*}})
// CHECK-NEXT: %[[ri0:.*]] = linalg.range %{{.*}}:%[[i0max]]:{{.*}} : !linalg.range
// CHECK: %[[rK:.*]] = linalg.range %{{.*}}:%{{.*}}:%{{.*}} : !linalg.range
// CHECK: %[[vA:.*]] = linalg.view %arg0[%[[ri0]], %[[rK]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[i1max:.*]] = affine.apply (d0) -> (d0 + 9)(%i1)
// CHECK-NEXT: %[[ri1:.*]] = linalg.range %i1:%[[i1max]]:%{{.*}} : !linalg.range
// CHECK-NEXT: %[[vB:.*]] = linalg.view %arg1[%7, %9] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: %[[vC:.*]] = linalg.view %arg2[%4, %9] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: affine.for %i2 = (d0) -> (d0)(%i0) to (d0) -> (d0)(%[[i0max]]) {
// CHECK-NEXT: affine.for %i3 = (d0) -> (d0)(%i1) to (d0) -> (d0)(%[[i1max]]) {
// CHECK-NEXT: affine.for %i4 = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK-NEXT: %{{.*}} = cmpi "eq", %i4, %c0 : index
// CHECK-NEXT: %{{.*}} = linalg.load %[[vC]][%i2, %i3] : !linalg.view<?x?xf32>
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %cst, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = linalg.load %[[vB]][%i4, %i3] : !linalg.view<?x?xf32>
// CHECK-NEXT: %{{.*}} = linalg.load %[[vA]][%i2, %i4] : !linalg.view<?x?xf32>
// CHECK: %[[vA:.*]] = linalg.view %{{.*}}[%[[ri0]], %[[rK]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: %[[i1max:.*]] = affine.apply (d0) -> (d0 + 9)(%{{.*}})
// CHECK-NEXT: %[[ri1:.*]] = linalg.range %{{.*}}:%[[i1max]]:%{{.*}} : !linalg.range
// CHECK-NEXT: %[[vB:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: %[[vC:.*]] = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)(%{{.*}}) to (d0) -> (d0)(%[[i0max]]) {
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)(%{{.*}}) to (d0) -> (d0)(%[[i1max]]) {
// CHECK-NEXT: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[K]]) {
// CHECK-NEXT: %{{.*}} = cmpi "eq", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = linalg.load %[[vC]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = linalg.load %[[vB]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK-NEXT: %{{.*}} = linalg.load %[[vA]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: linalg.store %{{.*}}, %[[vC]][%i2, %i3] : !linalg.view<?x?xf32>
// CHECK-NEXT: linalg.store %{{.*}}, %[[vC]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// clang-format on
cleanupAndPrintFunction(f);
}

143
mlir/lib/IR/AsmPrinter.cpp
View File

@ -37,6 +37,7 @@
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/ScopedHashTable.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
@ -71,7 +72,7 @@ static llvm::cl::opt<bool> printPrettyDebugInfo(
llvm::cl::desc("Print pretty debug info in MLIR output"),
llvm::cl::init(false));
// Use the generic op output form in the function printer even if the custom
// Use the generic op output form in the operation printer even if the custom
// form is defined.
static llvm::cl::opt<bool>
printGenericOpForm("mlir-print-op-generic",
@ -1126,7 +1127,7 @@ void ModulePrinter::printIntegerSet(IntegerSet set) {
}
//===----------------------------------------------------------------------===//
// Function printing
// Operation printing
//===----------------------------------------------------------------------===//
void ModulePrinter::printOptionalAttrDict(ArrayRef<NamedAttribute> attrs,
@ -1251,73 +1252,99 @@ public:
protected:
void numberValueID(Value *value);
void numberValuesInRegion(Region &region);
void numberValuesInBlock(Block &block);
void printValueID(Value *value, bool printResultNo = true) const;
private:
/// This is the value ID for each SSA value in the current function. If this
/// returns ~0, then the valueID has an entry in valueNames.
/// Uniques the given value name within the printer. If the given name
/// conflicts, it is automatically renamed.
StringRef uniqueValueName(StringRef name);
/// This is the value ID for each SSA value. If this returns ~0, then the
/// valueID has an entry in valueNames.
DenseMap<Value *, unsigned> valueIDs;
DenseMap<Value *, StringRef> valueNames;
/// This is the block ID for each block in the current function.
/// This is the block ID for each block in the current.
DenseMap<Block *, unsigned> blockIDs;
/// This keeps track of all of the non-numeric names that are in flight,
/// allowing us to check for duplicates.
llvm::StringSet<> usedNames;
/// Note: the value of the map is unused.
llvm::ScopedHashTable<StringRef, char> usedNames;
llvm::BumpPtrAllocator usedNameAllocator;
// This is the current indentation level for nested structures.
unsigned currentIndent = 0;
/// This is the next value ID to assign in numbering.
unsigned nextValueID = 0;
/// This is the ID to assign to the next region entry block argument.
unsigned nextRegionArgumentID = 0;
/// This is the next ID to assign to a Function argument.
/// This is the next ID to assign to a region entry block argument.
unsigned nextArgumentID = 0;
/// This is the next ID to assign when a name conflict is detected.
unsigned nextConflictID = 0;
/// This is the next block ID to assign in numbering.
unsigned nextBlockID = 0;
};
} // end anonymous namespace
OperationPrinter::OperationPrinter(Operation *op, ModulePrinter &other)
: ModulePrinter(other) {
for (auto *result : op->getResults())
numberValueID(result);
if (op->getNumResults() != 0)
numberValueID(op->getResult(0));
for (auto &region : op->getRegions())
for (auto &block : region)
numberValuesInBlock(block);
numberValuesInRegion(region);
}
OperationPrinter::OperationPrinter(Region *region, ModulePrinter &other)
: ModulePrinter(other) {
for (auto &block : *region)
numberValuesInBlock(block);
numberValuesInRegion(*region);
}
/// Number all of the SSA values in the specified block. Values get numbered
/// continuously throughout regions. In particular, we traverse the regions
/// held by operations and number values in depth-first pre-order.
void OperationPrinter::numberValuesInBlock(Block &block) {
// Each block gets a unique ID, and all of the operations within it get
// numbered as well.
blockIDs[&block] = nextBlockID++;
/// Number all of the SSA values in the specified region.
void OperationPrinter::numberValuesInRegion(Region &region) {
// Save the current value ids to allow for numbering values in sibling regions
// the same.
unsigned curValueID = nextValueID;
unsigned curArgumentID = nextArgumentID;
unsigned curConflictID = nextConflictID;
// Push a new used names scope.
llvm::ScopedHashTable<StringRef, char>::ScopeTy usedNamesScope(usedNames);
// Number the values within this region in a breadth-first order.
unsigned nextBlockID = 0;
for (auto &block : region) {
// Each block gets a unique ID, and all of the operations within it get
// numbered as well.
blockIDs[&block] = nextBlockID++;
numberValuesInBlock(block);
}
// After that we traverse the nested regions.
// TODO: Rework this loop to not use recursion.
for (auto &block : region) {
for (auto &op : block)
for (auto &nestedRegion : op.getRegions())
numberValuesInRegion(nestedRegion);
}
// Restore the original value ids.
nextValueID = curValueID;
nextArgumentID = curArgumentID;
nextConflictID = curConflictID;
}
/// Number all of the SSA values in the specified block, without traversing
/// nested regions.
void OperationPrinter::numberValuesInBlock(Block &block) {
// Number the block arguments.
for (auto *arg : block.getArguments())
numberValueID(arg);
for (auto &op : block) {
// We number operation that have results, and we only number the first
// result.
// We number operation that have results, and we only number the first result.
for (auto &op : block)
if (op.getNumResults() != 0)
numberValueID(op.getResult(0));
for (auto &region : op.getRegions())
for (auto &block : region)
numberValuesInBlock(block);
}
}
void OperationPrinter::numberValueID(Value *value) {
@ -1351,16 +1378,12 @@ void OperationPrinter::numberValueID(Value *value) {
if (specialNameBuffer.empty()) {
switch (value->getKind()) {
case Value::Kind::BlockArgument:
// If this is an argument to the function, give it an 'arg' name. If the
// argument is to an entry block of an operation region, give it an 'i'
// If this is an argument to the entry block of a region, give it an 'arg'
// name.
if (auto *block = cast<BlockArgument>(value)->getOwner()) {
auto *parentRegion = block->getParent();
if (parentRegion && block == &parentRegion->front()) {
if (llvm::isa<FuncOp>(parentRegion->getContainingOp()))
specialName << "arg" << nextArgumentID++;
else
specialName << "i" << nextRegionArgumentID++;
specialName << "arg" << nextArgumentID++;
break;
}
}
@ -1377,28 +1400,33 @@ void OperationPrinter::numberValueID(Value *value) {
// Ok, this value had an interesting name. Remember it with a sentinel.
valueIDs[value] = nameSentinel;
valueNames[value] = uniqueValueName(specialName.str());
}
// Remember that we've used this name, checking to see if we had a conflict.
auto insertRes = usedNames.insert(specialName.str());
if (insertRes.second) {
// If this is the first use of the name, then we're successful!
valueNames[value] = insertRes.first->first();
return;
}
// Otherwise, we had a conflict - probe until we find a unique name. This
// is guaranteed to terminate (and usually in a single iteration) because it
// generates new names by incrementing nextConflictID.
while (1) {
std::string probeName =
specialName.str().str() + "_" + llvm::utostr(nextConflictID++);
insertRes = usedNames.insert(probeName);
if (insertRes.second) {
// If this is the first use of the name, then we're successful!
valueNames[value] = insertRes.first->first();
return;
/// Uniques the given value name within the printer. If the given name
/// conflicts, it is automatically renamed.
StringRef OperationPrinter::uniqueValueName(StringRef name) {
// Check to see if this name is already unique.
if (!usedNames.count(name)) {
name = name.copy(usedNameAllocator);
} else {
// Otherwise, we had a conflict - probe until we find a unique name. This
// is guaranteed to terminate (and usually in a single iteration) because it
// generates new names by incrementing nextConflictID.
SmallString<64> probeName(name);
probeName.push_back('_');
while (1) {
probeName.resize(name.size() + 1);
probeName += llvm::utostr(nextConflictID++);
if (!usedNames.count(probeName)) {
name = StringRef(probeName).copy(usedNameAllocator);
break;
}
}
}
usedNames.insert(name, char());
return name;
}
void OperationPrinter::print(Block *block, bool printBlockArgs,
@ -1590,9 +1618,10 @@ void ModulePrinter::print(ModuleOp module) {
// Print the module body without the terminator. The terminator is not printed
// as part of the custom syntax for modules.
OperationPrinter opPrinter(module, *this);
auto *moduleBody = module.getBody();
for (auto &op : llvm::make_range(moduleBody->begin(), --moduleBody->end()))
OperationPrinter(&op, *this).print(&op);
opPrinter.print(&op);
}
//===----------------------------------------------------------------------===//

70
mlir/test/AffineOps/canonicalize.mlir
View File

@ -51,7 +51,7 @@ func @compose_affine_maps_1dto2d_no_symbols() {
%x1_0 = affine.apply (d0, d1) -> (d0) (%x0, %x0)
%x1_1 = affine.apply (d0, d1) -> (d1) (%x0, %x0)
// CHECK: [[I0A:%[0-9]+]] = affine.apply [[MAP0]](%i0)
// CHECK: [[I0A:%[0-9]+]] = affine.apply [[MAP0]](%{{.*}})
// CHECK-NEXT: load %0{{\[}}[[I0A]], [[I0A]]{{\]}}
%v0 = load %0[%x1_0, %x1_1] : memref<4x4xf32>
@ -60,7 +60,7 @@ func @compose_affine_maps_1dto2d_no_symbols() {
%y1_0 = affine.apply (d0, d1) -> (d0) (%y0, %y0)
%y1_1 = affine.apply (d0, d1) -> (d1) (%y0, %y0)
// CHECK-NEXT: [[I1A:%[0-9]+]] = affine.apply [[MAP1]](%i0)
// CHECK-NEXT: [[I1A:%[0-9]+]] = affine.apply [[MAP1]](%{{.*}})
// CHECK-NEXT: load %0{{\[}}[[I1A]], [[I1A]]{{\]}}
%v1 = load %0[%y1_0, %y1_1] : memref<4x4xf32>
@ -89,20 +89,20 @@ func @compose_affine_maps_1dto2d_with_symbols() {
%c4 = constant 4 : index
%x0 = affine.apply (d0)[s0] -> (d0 - s0) (%i0)[%c4]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP4]](%i0)[%c4]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP4]](%{{.*}})[%{{.*}}]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I0]]{{\]}}
%v0 = load %0[%x0, %x0] : memref<4x4xf32>
// Test load[%x0, %x1] with symbol %c4 captured by '%x0' map.
%x1 = affine.apply (d0) -> (d0 + 1) (%i0)
%y1 = affine.apply (d0, d1) -> (d0+d1) (%x0, %x1)
// CHECK-NEXT: [[I1:%[0-9]+]] = affine.apply [[MAP6]](%i0)[%c4]
// CHECK-NEXT: [[I1:%[0-9]+]] = affine.apply [[MAP6]](%{{.*}})[%{{.*}}]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I1]], [[I1]]{{\]}}
%v1 = load %0[%y1, %y1] : memref<4x4xf32>
// Test load[%x1, %x0] with symbol %c4 captured by '%x0' map.
%y2 = affine.apply (d0, d1) -> (d0 + d1) (%x1, %x0)
// CHECK-NEXT: [[I2:%[0-9]+]] = affine.apply [[MAP6]](%i0)[%c4]
// CHECK-NEXT: [[I2:%[0-9]+]] = affine.apply [[MAP6]](%{{.*}})[%{{.*}}]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I2]], [[I2]]{{\]}}
%v2 = load %0[%y2, %y2] : memref<4x4xf32>
@ -110,7 +110,7 @@ func @compose_affine_maps_1dto2d_with_symbols() {
%c5 = constant 5 : index
%x2 = affine.apply (d0)[s0] -> (d0 + s0) (%i0)[%c5]
%y3 = affine.apply (d0, d1) -> (d0 + d1) (%x2, %x0)
// CHECK: [[I3:%[0-9]+]] = affine.apply [[MAP7]](%i0)[%c5, %c4]
// CHECK: [[I3:%[0-9]+]] = affine.apply [[MAP7]](%{{.*}})[%{{.*}}, %{{.*}}]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I3]], [[I3]]{{\]}}
%v3 = load %0[%y3, %y3] : memref<4x4xf32>
}
@ -138,8 +138,8 @@ func @compose_affine_maps_2d_tile() {
((d0 * s0) + d2) (%x0, %x1, %x2, %x3)[%c4, %c8]
%x41 = affine.apply (d0, d1, d2, d3)[s0, s1] ->
((d1 * s1) + d3) (%x0, %x1, %x2, %x3)[%c4, %c8]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP8]](%i0, %i2)[%c4]
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP8]](%i1, %i3)[%c8]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP8]](%{{.*}}, %{{.*}})[%{{.*}}]
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP8]](%{{.*}}, %{{.*}})[%{{.*}}]
// CHECK-NEXT: [[L0:%[0-9]+]] = load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
%v0 = load %0[%x40, %x41] : memref<16x32xf32>
@ -170,9 +170,9 @@ func @compose_affine_maps_dependent_loads() {
%x02 = affine.apply (d0, d1, d2)[s0, s1] -> (d2 * s0)
(%i0, %i1, %i2)[%c3, %c7]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP9]](%i0)[%c3]
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP4]](%i1)[%c7]
// CHECK: [[I2:%[0-9]+]] = affine.apply [[MAP10]](%i2)[%c3]
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP9]](%{{.*}})[%{{.*}}]
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP4]](%{{.*}})[%{{.*}}]
// CHECK: [[I2:%[0-9]+]] = affine.apply [[MAP10]](%{{.*}})[%{{.*}}]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
%v0 = load %0[%x00, %x01] : memref<16x32xf32>
@ -189,8 +189,8 @@ func @compose_affine_maps_dependent_loads() {
%x11 = affine.apply (d0, d1)[s0, s1] -> (d1 ceildiv s0)
(%x01, %x00)[%c7, %c3]
// CHECK-NEXT: [[I2A:%[0-9]+]] = affine.apply [[MAP12]](%i1)[%c7]
// CHECK-NEXT: [[I2B:%[0-9]+]] = affine.apply [[MAP11]](%i0)[%c3, %c7]
// CHECK-NEXT: [[I2A:%[0-9]+]] = affine.apply [[MAP12]](%{{.*}})[%{{.*}}]
// CHECK-NEXT: [[I2B:%[0-9]+]] = affine.apply [[MAP11]](%{{.*}})[%{{.*}}, %{{.*}}]
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I2A]], [[I2B]]{{\]}}
%v3 = load %0[%x10, %x11] : memref<16x32xf32>
}
@ -209,8 +209,8 @@ func @compose_affine_maps_diamond_dependency() {
%c = affine.apply (d0) -> (d0 * 4) (%a)
%d0 = affine.apply (d0, d1) -> (d0 ceildiv 8) (%b, %c)
%d1 = affine.apply (d0, d1) -> (d1 floordiv 3) (%b, %c)
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP13A]](%i0)
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP13B]](%i0)
// CHECK: [[I0:%[0-9]+]] = affine.apply [[MAP13A]](%{{.*}})
// CHECK: [[I1:%[0-9]+]] = affine.apply [[MAP13B]](%{{.*}})
// CHECK-NEXT: load %{{[0-9]+}}{{\[}}[[I0]], [[I1]]{{\]}}
%v = load %0[%d0, %d1] : memref<4x4xf32>
}
@ -229,7 +229,7 @@ func @arg_used_as_dim_and_symbol(%arg0: memref<100x100xf32>, %arg1: index) {
(%i0, %i1)[%arg1, %c9]
%4 = affine.apply (d0, d1, d3) -> (d3 - (d0 + d1))
(%arg1, %c9, %3)
// CHECK: load %{{[0-9]+}}{{\[}}%i1, %arg1{{\]}}
// CHECK: load %{{[0-9]+}}{{\[}}%{{.*}}, %{{.*}}{{\]}}
%5 = load %1[%4, %arg1] : memref<100x100xf32, 1>
}
}
@ -261,18 +261,18 @@ func @partial_fold_map(%arg0: memref<index>, %arg1: index, %arg2: index) {
%c42 = constant 42 : index
%2 = affine.apply (d0, d1) -> (d0 - d1) (%arg1, %c42)
store %2, %arg0[] : memref<index>
// CHECK: [[X:%[0-9]+]] = affine.apply [[MAP15]]()[%arg1, %c42]
// CHECK-NEXT: store [[X]], %arg0
// CHECK: [[X:%[0-9]+]] = affine.apply [[MAP15]]()[%{{.*}}, %{{.*}}]
// CHECK-NEXT: store [[X]], %{{.*}}
return
}
// CHECK-LABEL: func @symbolic_composition_a(%arg0: index, %arg1: index) -> index {
// CHECK-LABEL: func @symbolic_composition_a(%{{.*}}: index, %{{.*}}: index) -> index {
func @symbolic_composition_a(%arg0: index, %arg1: index) -> index {
%0 = affine.apply (d0) -> (d0 * 4)(%arg0)
%1 = affine.apply ()[s0, s1] -> (8 * s0)()[%0, %arg0]
%2 = affine.apply ()[s0, s1] -> (16 * s1)()[%arg1, %1]
// CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_a]]()[%arg0]
// CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_a]]()[%{{.*}}]
return %2 : index
}
@ -280,7 +280,7 @@ func @symbolic_composition_a(%arg0: index, %arg1: index) -> index {
func @symbolic_composition_b(%arg0: index, %arg1: index, %arg2: index, %arg3: index) -> index {
%0 = affine.apply (d0) -> (d0)(%arg0)
%1 = affine.apply ()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)()[%0, %0, %0, %0]
// CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_b]]()[%arg0]
// CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_b]]()[%{{.*}}]
return %1 : index
}
@ -289,7 +289,7 @@ func @symbolic_composition_c(%arg0: index, %arg1: index, %arg2: index, %arg3: in
%0 = affine.apply (d0) -> (d0)(%arg0)
%1 = affine.apply (d0) -> (d0)(%arg1)
%2 = affine.apply ()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)()[%0, %0, %0, %1]
// CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_c]]()[%arg0, %arg1]
// CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_c]]()[%{{.*}}, %{{.*}}]
return %2 : index
}
@ -298,7 +298,7 @@ func @symbolic_composition_d(%arg0: index, %arg1: index, %arg2: index, %arg3: in
%0 = affine.apply (d0) -> (d0)(%arg0)
%1 = affine.apply ()[s0] -> (s0)()[%arg1]
%2 = affine.apply ()[s0, s1, s2, s3] -> (s0 + s1 + s2 + s3)()[%0, %0, %0, %1]
// CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_d]]()[%arg1, %arg0]
// CHECK: %{{.*}} = affine.apply [[map_symbolic_composition_d]]()[%{{.*}}, %{{.*}}]
return %2 : index
}
@ -307,7 +307,7 @@ func @symbolic_composition_d(%arg0: index, %arg1: index, %arg2: index, %arg3: in
func @mix_dims_and_symbols_b(%arg0: index, %arg1: index) -> index {
%a = affine.apply (d0)[s0] -> (d0 - 1 + 42 * s0) (%arg0)[%arg1]
%b = affine.apply (d0) -> (d0 + 7) (%a)
// CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_b]]()[%arg1, %arg0]
// CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_b]]()[%{{.*}}, %{{.*}}]
return %b : index
}
@ -317,7 +317,7 @@ func @mix_dims_and_symbols_c(%arg0: index, %arg1: index) -> index {
%a = affine.apply (d0)[s0] -> (d0 - 1 + 42 * s0) (%arg0)[%arg1]
%b = affine.apply (d0) -> (d0 + 7) (%a)
%c = affine.apply (d0) -> (d0 * 4) (%a)
// CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_c]]()[%arg1, %arg0]
// CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_c]]()[%{{.*}}, %{{.*}}]
return %c : index
}
@ -327,7 +327,7 @@ func @mix_dims_and_symbols_d(%arg0: index, %arg1: index) -> index {
%b = affine.apply (d0) -> (d0 + 7) (%a)
%c = affine.apply (d0) -> (d0 * 4) (%a)
%d = affine.apply ()[s0] -> (s0 ceildiv 8) ()[%b]
// CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_d]]()[%arg1, %arg0]
// CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_d]]()[%{{.*}}, %{{.*}}]
return %d : index
}
@ -338,7 +338,7 @@ func @mix_dims_and_symbols_e(%arg0: index, %arg1: index) -> index {
%c = affine.apply (d0) -> (d0 * 4) (%a)
%d = affine.apply ()[s0] -> (s0 ceildiv 8) ()[%b]
%e = affine.apply (d0) -> (d0 floordiv 3) (%c)
// CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_e]]()[%arg1, %arg0]
// CHECK: {{.*}} = affine.apply [[map_mix_dims_and_symbols_e]]()[%{{.*}}, %{{.*}}]
return %e : index
}
@ -362,8 +362,8 @@ func @mix_dims_and_symbols_g(%M: index, %N: index) -> (index, index, index) {
%res2 = affine.apply ()[s0, s1] -> (s1)()[%N, %K]
%res3 = affine.apply ()[s0, s1] -> (1024)()[%N, %K]
// CHECK-DAG: {{.*}} = constant 1024 : index
// CHECK-DAG: {{.*}} = affine.apply [[map_symbolic_composition_b]]()[%arg1]
// CHECK-DAG: {{.*}} = affine.apply [[map_symbolic_composition_b]]()[%arg0]
// CHECK-DAG: {{.*}} = affine.apply [[map_symbolic_composition_b]]()[%{{.*}}]
// CHECK-DAG: {{.*}} = affine.apply [[map_symbolic_composition_b]]()[%{{.*}}]
return %res1, %res2, %res3 : index, index, index
}
@ -373,7 +373,7 @@ func @symbolic_semi_affine(%M: index, %N: index, %A: memref<?xf32>) {
affine.for %i0 = 1 to 100 {
%1 = affine.apply ()[s0] -> (s0 + 1) ()[%M]
%2 = affine.apply (d0)[s0] -> (d0 floordiv s0) (%i0)[%1]
// CHECK-DAG: {{.*}} = affine.apply [[symbolic_semi_affine]](%i0)[%arg0]
// CHECK-DAG: {{.*}} = affine.apply [[symbolic_semi_affine]](%{{.*}})[%{{.*}}]
store %f1, %A[%2] : memref<?xf32>
}
return
@ -386,27 +386,27 @@ func @symbolic_semi_affine(%M: index, %N: index, %A: memref<?xf32>) {
// CHECK-LABEL: func @constant_fold_bounds(%arg0: index) {
func @constant_fold_bounds(%N : index) {
// CHECK: %c3 = constant 3 : index
// CHECK-NEXT: %0 = "foo"() : () -> index
// CHECK: constant 3 : index
// CHECK-NEXT: "foo"() : () -> index
%c9 = constant 9 : index
%c1 = constant 1 : index
%c2 = constant 2 : index
%c3 = affine.apply (d0, d1) -> (d0 + d1) (%c1, %c2)
%l = "foo"() : () -> index
// CHECK: affine.for %i0 = 5 to 7 {
// CHECK: affine.for %{{.*}} = 5 to 7 {
affine.for %i = max (d0, d1) -> (0, d0 + d1)(%c2, %c3) to min (d0, d1) -> (d0 - 2, 32*d1) (%c9, %c1) {
"foo"(%i, %c3) : (index, index) -> ()
}
// Bound takes a non-constant argument but can still be folded.
// CHECK: affine.for %i1 = 1 to 7 {
// CHECK: affine.for %{{.*}} = 1 to 7 {
affine.for %j = max (d0) -> (0, 1)(%N) to min (d0, d1) -> (7, 9)(%N, %l) {
"foo"(%j, %c3) : (index, index) -> ()
}
// None of the bounds can be folded.
// CHECK: affine.for %i2 = max [[MAP0]]()[%0] to min [[MAP1]]()[%arg0] {
// CHECK: affine.for %{{.*}} = max [[MAP0]]()[%{{.*}}] to min [[MAP1]]()[%{{.*}}] {
affine.for %k = max ()[s0] -> (0, s0) ()[%l] to min ()[s0] -> (100, s0)()[%N] {
"foo"(%k, %c3) : (index, index) -> ()
}

20
mlir/test/AffineOps/dma.mlir
View File

@ -16,8 +16,8 @@ func @test0(%arg0 : index, %arg1 : index) {
affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64
: memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
affine.dma_wait %2[%c0], %c64 : memref<1xi32>
// CHECK: affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64 : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %2[%c0], %c64 : memref<1xi32>
// CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
}
}
return
@ -41,8 +41,8 @@ func @test1(%arg0 : index, %arg1 : index) {
affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64, %c128, %c256
: memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
affine.dma_wait %2[%c0], %c64 : memref<1xi32>
// CHECK: affine.dma_start %0[%i0, %i1], %1[%i0, %i1], %2[%c0], %c64, %c128, %c256 : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %2[%c0], %c64 : memref<1xi32>
// CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
}
}
return
@ -66,8 +66,8 @@ func @test2(%arg0 : index, %arg1 : index) {
%2[%c0], %c64
: memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
affine.dma_wait %2[%c0], %c64 : memref<1xi32>
// CHECK: affine.dma_start %0[%i0 + %arg0, %i1], %1[%i0, %i1 + %arg1 + 5], %2[%c0], %c64 : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %2[%c0], %c64 : memref<1xi32>
// CHECK: affine.dma_start %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}} + %{{.*}} + 5], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
}
}
return
@ -93,8 +93,8 @@ func @test3(%arg0 : index, %arg1 : index) {
%2[%i0 + %i1 + 11], %c64
: memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
affine.dma_wait %2[%c0], %c64 : memref<1xi32>
// CHECK: affine.dma_start %0[%i0 + symbol(%arg0), %i1], %1[%i0, %i1 + symbol(%arg1) + 7], %2[%i0 + %i1 + 11], %c64 : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %2[%c0], %c64 : memref<1xi32>
// CHECK: affine.dma_start %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}} + symbol(%{{.*}}) + 7], %{{.*}}[%{{.*}} + %{{.*}} + 11], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
}
}
return
@ -119,8 +119,8 @@ func @test4(%arg0 : index, %arg1 : index) {
%2[%i0 + %i1 + 11], %c64
: memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
affine.dma_wait %2[%i0 + %i1 + 11], %c64 : memref<1xi32>
// CHECK: affine.dma_start %0[(%i0 + symbol(%arg0)) floordiv 3, %i1], %1[%i0, (%i1 + symbol(%arg1)) mod 9 + 7], %2[%i0 + %i1 + 11], %c64 : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %2[%i0 + %i1 + 11], %c64 : memref<1xi32>
// CHECK: affine.dma_start %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3, %{{.*}}], %{{.*}}[%{{.*}}, (%{{.*}} + symbol(%{{.*}})) mod 9 + 7], %{{.*}}[%{{.*}} + %{{.*}} + 11], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %{{.*}}[%{{.*}} + %{{.*}} + 11], %{{.*}} : memref<1xi32>
}
}
return

34
mlir/test/AffineOps/load-store.mlir
View File

@ -10,7 +10,7 @@ func @test0(%arg0 : index, %arg1 : index) {
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%i0, %i1] : memref<100x100xf32>
// CHECK: %1 = affine.load %0[%i0, %i1] : memref<100x100xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<100x100xf32>
}
}
return
@ -27,8 +27,8 @@ func @test1(%arg0 : index, %arg1 : index) {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
affine.store %1, %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
// CHECK: %1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
// CHECK: affine.store %1, %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>
}
}
return
@ -46,8 +46,8 @@ func @test2(%arg0 : index, %arg1 : index) {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
affine.store %1, %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
// CHECK: %1 = affine.load %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
// CHECK: affine.store %1, %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}] : memref<100x100xf32>
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}] : memref<100x100xf32>
}
}
return
@ -67,8 +67,8 @@ func @test3(%arg0 : index, %arg1 : index) {
: memref<100x100xf32>
affine.store %1, %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)]
: memref<100x100xf32>
// CHECK: %1 = affine.load %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)] : memref<100x100xf32>
// CHECK: affine.store %1, %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)] : memref<100x100xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + symbol(%{{.*}})] : memref<100x100xf32>
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + symbol(%{{.*}})] : memref<100x100xf32>
}
}
return
@ -87,8 +87,8 @@ func @test4(%arg0 : index, %arg1 : index) {
(%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
affine.store %1, %0[(%i0 + symbol(%arg0)) floordiv 3 + 11,
(%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
// CHECK: %1 = affine.load %0[(%i0 + symbol(%arg0)) floordiv 3 + 11, (%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
// CHECK: affine.store %1, %0[(%i0 + symbol(%arg0)) floordiv 3 + 11, (%i1 + symbol(%arg1)) mod 4 + 7] : memref<100x100xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3 + 11, (%{{.*}} + symbol(%{{.*}})) mod 4 + 7] : memref<100x100xf32>
// CHECK: affine.store %{{.*}}, %{{.*}}[(%{{.*}} + symbol(%{{.*}})) floordiv 3 + 11, (%{{.*}} + symbol(%{{.*}})) mod 4 + 7] : memref<100x100xf32>
}
}
return
@ -106,8 +106,8 @@ func @test5(%arg0 : index, %arg1 : index) {
affine.for %i2 = 0 to 10 {
%1 = affine.load %0[%i2, %i0, %i1] : memref<10x10x10xf32>
affine.store %1, %0[%i2, %i0, %i1] : memref<10x10x10xf32>
// CHECK: %1 = affine.load %0[%i2, %i0, %i1] : memref<10x10x10xf32>
// CHECK: affine.store %1, %0[%i2, %i0, %i1] : memref<10x10x10xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<10x10x10xf32>
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<10x10x10xf32>
}
}
}
@ -130,8 +130,8 @@ func @test6(%arg0 : index, %arg1 : index) {
: memref<10x10x10xf32>
affine.store %1, %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1]
: memref<10x10x10xf32>
// CHECK: %1 = affine.load %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1] : memref<10x10x10xf32>
// CHECK: affine.store %1, %0[%i2 + %arg0, %i0 + %i1, %i1 + %arg0 + %arg1] : memref<10x10x10xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}, %{{.*}} + %{{.*}} + %{{.*}}] : memref<10x10x10xf32>
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + %{{.*}}, %{{.*}} + %{{.*}}, %{{.*}} + %{{.*}} + %{{.*}}] : memref<10x10x10xf32>
}
}
}
@ -159,8 +159,8 @@ func @test6(%arg0 : index, %arg1 : index) {
%i0 + %i1,
%i1 + symbol(%arg0) + symbol(%arg1)]
: memref<10x10x10xf32>
// CHECK: %1 = affine.load %0[%i2 + symbol(%arg0), %i0 + %i1, %i1 + symbol(%arg0) + symbol(%arg1)] : memref<10x10x10xf32>
// CHECK: affine.store %1, %0[%i2 + symbol(%arg0), %i0 + %i1, %i1 + symbol(%arg0) + symbol(%arg1)] : memref<10x10x10xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + %{{.*}}, %{{.*}} + symbol(%{{.*}}) + symbol(%{{.*}})] : memref<10x10x10xf32>
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}} + symbol(%{{.*}}), %{{.*}} + %{{.*}}, %{{.*}} + symbol(%{{.*}}) + symbol(%{{.*}})] : memref<10x10x10xf32>
}
}
}
@ -178,8 +178,8 @@ func @test7() {
%1 = affine.apply (d1) -> (d1 + 1)(%i0)
%2 = affine.load %0[%1] : memref<10xf32>
affine.store %2, %0[%1] : memref<10xf32>
// CHECK: affine.load %0[%1] : memref<10xf32>
// CHECK: affine.store %2, %0[%1] : memref<10xf32>
// CHECK: affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
}
return
}

8
mlir/test/AffineOps/ops.mlir
View File

@ -5,11 +5,11 @@
// Check that `affine.terminator` is visible in the generic form.
// CHECK-LABEL: @empty
func @empty() {
// CHECK: affine.for %i
// CHECK: affine.for
// CHECK-NEXT: } {some_attr = true}
//
// GENERIC: "affine.for"()
// GENERIC-NEXT: ^bb1(%i0: index):
// GENERIC-NEXT: ^bb0(%{{.*}}: index):
// GENERIC-NEXT: "affine.terminator"() : () -> ()
// GENERIC-NEXT: })
affine.for %i = 0 to 10 {
@ -46,11 +46,11 @@ func @empty() {
// Check that no extra terminator is introduced.
// CHEKC-LABEL: @affine_terminator
func @affine_terminator() {
// CHECK: affine.for %i
// CHECK: affine.for
// CHECK-NEXT: }
//
// GENERIC: "affine.for"() ( {
// GENERIC-NEXT: ^bb1(%i0: index): // no predecessors
// GENERIC-NEXT: ^bb0(%{{.*}}: index): // no predecessors
// GENERIC-NEXT: "affine.terminator"() : () -> ()
// GENERIC-NEXT: }) {lower_bound = #map0, step = 1 : index, upper_bound = #map1} : () -> ()
affine.for %i = 0 to 10 {

22
mlir/test/Conversion/LoopsToGPU/linalg_to_gpu.mlir
View File

@ -5,23 +5,23 @@ func @foo(%arg0: !linalg.buffer<?xf32>, %arg1 : index) {
%c0 = constant 0 : index
%c42 = constant 42 : index
%c3 = constant 3 : index
// CHECK: subi %c42, %c0 : index
// CHECK-NEXT: %[[range_i:.*]] = divis {{.*}}, %c3 : index
// CHECK: subi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %[[range_i:.*]] = divis {{.*}}, %{{.*}} : index
linalg.for %i0 = %c0 to %c42 step %c3 {
// CHECK: subi %c42, %c3 : index
// CHECK-NEXT: %[[range_j:.*]] = divis {{.*}}, %arg1 : index
// CHECK: subi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %[[range_j:.*]] = divis {{.*}}, %{{.*}} : index
linalg.for %i1 = %c3 to %c42 step %arg1 {
// CHECK: gpu.launch
// CHECK-SAME: blocks(%i0, %i1, %i2) in (%i6 = %[[range_i]], %i7 = %c1, %i8 = %c1)
// CHECK-SAME: threads(%i3, %i4, %i5) in (%i9 = %[[range_j]], %i10 = %c1, %i11 = %c1)
// CHECK-SAME: args(%i12 = %c0, %i13 = %c3, %i14 = %c3, %i15 = %arg1)
// CHECK-SAME: blocks
// CHECK-SAME: threads
// CHECK-SAME: args
// Replacements of loop induction variables. Take a product with the
// step and add the lower bound.
// CHECK: %[[prod_i:.*]] = muli %i14, %i0 : index
// CHECK: addi %i12, %[[prod_i]] : index
// CHECK: %[[prod_j:.*]] = muli %i15, %i3 : index
// CHECK: addi %i13, %[[prod_j]] : index
// CHECK: %[[prod_i:.*]] = muli %{{.*}}, %{{.*}} : index
// CHECK: addi %{{.*}}, %[[prod_i]] : index
// CHECK: %[[prod_j:.*]] = muli %{{.*}}, %{{.*}} : index
// CHECK: addi %{{.*}}, %[[prod_j]] : index
// CHECK: gpu.return
}

80
mlir/test/Conversion/LoopsToGPU/step_one.mlir
View File

@ -5,72 +5,72 @@
// CHECK-22-LABEL: @step_1
func @step_1(%A : memref<?x?x?x?xf32>, %B : memref<?x?x?x?xf32>) {
// Bounds of the loop, its range and step.
// CHECK-11-NEXT: %c0 = constant 0 : index
// CHECK-11-NEXT: %c42 = constant 42 : index
// CHECK-11-NEXT: %0 = subi %c42, %c0 : index
// CHECK-11-NEXT: %c1 = constant 1 : index
// CHECK-11-NEXT: %{{.*}} = constant 0 : index
// CHECK-11-NEXT: %{{.*}} = constant 42 : index
// CHECK-11-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-11-NEXT: %{{.*}} = constant 1 : index
//
// CHECK-22-NEXT: %c0 = constant 0 : index
// CHECK-22-NEXT: %c42 = constant 42 : index
// CHECK-22-NEXT: %0 = subi %c42, %c0 : index
// CHECK-22-NEXT: %c1 = constant 1 : index
// CHECK-22-NEXT: %{{.*}} = constant 0 : index
// CHECK-22-NEXT: %{{.*}} = constant 42 : index
// CHECK-22-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-22-NEXT: %{{.*}} = constant 1 : index
affine.for %i = 0 to 42 {
// Bounds of the loop, its range and step.
// CHECK-11-NEXT: %c0_0 = constant 0 : index
// CHECK-11-NEXT: %c10 = constant 10 : index
// CHECK-11-NEXT: %1 = subi %c10, %c0_0 : index
// CHECK-11-NEXT: %c1_1 = constant 1 : index
// CHECK-11-NEXT: %{{.*}} = constant 0 : index
// CHECK-11-NEXT: %{{.*}} = constant 10 : index
// CHECK-11-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-11-NEXT: %{{.*}} = constant 1 : index
//
// CHECK-22-NEXT: %c0_0 = constant 0 : index
// CHECK-22-NEXT: %c10 = constant 10 : index
// CHECK-22-NEXT: %1 = subi %c10, %c0_0 : index
// CHECK-22-NEXT: %c1_1 = constant 1 : index
// CHECK-22-NEXT: %{{.*}} = constant 0 : index
// CHECK-22-NEXT: %{{.*}} = constant 10 : index
// CHECK-22-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-22-NEXT: %{{.*}} = constant 1 : index
affine.for %j = 0 to 10 {
// CHECK-11: gpu.launch
// CHECK-11-SAME: blocks(%i0, %i1, %i2) in (%i6 = %0, %i7 = %c1_2, %i8 = %c1_2)
// CHECK-11-SAME: threads(%i3, %i4, %i5) in (%i9 = %1, %i10 = %c1_2, %i11 = %c1_2)
// CHECK-11-SAME: args(%i12 = %arg0, %i13 = %arg1, %i14 = %c0, %i15 = %c0_0, %i16 = %c1, %i17 = %c1_1)
// CHECK-11-SAME: blocks
// CHECK-11-SAME: threads
// CHECK-11-SAME: args
// Remapping of the loop induction variables.
// CHECK-11: %[[i:.*]] = addi %i14, %i0 : index
// CHECK-11-NEXT: %[[j:.*]] = addi %i15, %i3 : index
// CHECK-11: %[[i:.*]] = addi %{{.*}}, %{{.*}} : index
// CHECK-11-NEXT: %[[j:.*]] = addi %{{.*}}, %{{.*}} : index
// This loop is not converted if mapping to 1, 1 dimensions.
// CHECK-11-NEXT: affine.for %[[ii:.*]] = 2 to 16
//
// Bounds of the loop, its range and step.
// CHECK-22-NEXT: %c2 = constant 2 : index
// CHECK-22-NEXT: %c16 = constant 16 : index
// CHECK-22-NEXT: %2 = subi %c16, %c2 : index
// CHECK-22-NEXT: %c1_2 = constant 1 : index
// CHECK-22-NEXT: %{{.*}} = constant 2 : index
// CHECK-22-NEXT: %{{.*}} = constant 16 : index
// CHECK-22-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-22-NEXT: %{{.*}} = constant 1 : index
affine.for %ii = 2 to 16 {
// This loop is not converted if mapping to 1, 1 dimensions.
// CHECK-11-NEXT: affine.for %[[jj:.*]] = 5 to 17
//
// Bounds of the loop, its range and step.
// CHECK-22-NEXT: %c5 = constant 5 : index
// CHECK-22-NEXT: %c17 = constant 17 : index
// CHECK-22-NEXT: %3 = subi %c17, %c5 : index
// CHECK-22-NEXT: %c1_3 = constant 1 : index
// CHECK-22-NEXT: %{{.*}} = constant 5 : index
// CHECK-22-NEXT: %{{.*}} = constant 17 : index
// CHECK-22-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-22-NEXT: %{{.*}} = constant 1 : index
affine.for %jj = 5 to 17 {
// CHECK-22: gpu.launch
// CHECK-22-SAME: blocks(%i0, %i1, %i2) in (%i6 = %0, %i7 = %1, %i8 = %c1_4)
// CHECK-22-SAME: threads(%i3, %i4, %i5) in (%i9 = %2, %i10 = %3, %i11 = %c1_4)
// CHECK-22-SAME: args(%i12 = %arg0, %i13 = %arg1, %i14 = %c0, %i15 = %c0_0, %i16 = %c2, %i17 = %c5, %i18 = %c1, %i19 = %c1_1, %i20 = %c1_2, %i21 = %c1_3)
// CHECK-22-SAME: blocks
// CHECK-22-SAME: threads
// CHECK-22-SAME: args
// Remapping of the loop induction variables in the last mapped loop.
// CHECK-22: %[[i:.*]] = addi %i14, %i0 : index
// CHECK-22-NEXT: %[[j:.*]] = addi %i15, %i1 : index
// CHECK-22-NEXT: %[[ii:.*]] = addi %i16, %i3 : index
// CHECK-22-NEXT: %[[jj:.*]] = addi %i17, %i4 : index
// CHECK-22: %[[i:.*]] = addi %{{.*}}, %{{.*}} : index
// CHECK-22-NEXT: %[[j:.*]] = addi %{{.*}}, %{{.*}} : index
// CHECK-22-NEXT: %[[ii:.*]] = addi %{{.*}}, %{{.*}} : index
// CHECK-22-NEXT: %[[jj:.*]] = addi %{{.*}}, %{{.*}} : index
// Using remapped values instead of loop iterators.
// CHECK-11: {{.*}} = load %i12[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
// CHECK-22: {{.*}} = load %i12[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
// CHECK-11: {{.*}} = load %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
// CHECK-22: {{.*}} = load %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
%0 = load %A[%i, %j, %ii, %jj] : memref<?x?x?x?xf32>
// CHECK-11-NEXT: store {{.*}}, %i13[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
// CHECK-22-NEXT: store {{.*}}, %i13[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
// CHECK-11-NEXT: store {{.*}}, %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
// CHECK-22-NEXT: store {{.*}}, %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
store %0, %B[%i, %j, %ii, %jj] : memref<?x?x?x?xf32>
// CHECK-11: gpu.return

20
mlir/test/Conversion/LoopsToGPU/step_positive.mlir
View File

@ -3,24 +3,24 @@
// CHECK-LABEL: @step_var
func @step_var(%A : memref<?x?xf32>, %B : memref<?x?xf32>) {
// Check that we divide by step.
// CHECK: %[[range_i:.*]] = divis {{.*}}, %c4
// CHECK: %[[range_j:.*]] = divis {{.*}}, %c7
// CHECK: %[[range_i:.*]] = divis {{.*}}, %{{.*}}
// CHECK: %[[range_j:.*]] = divis {{.*}}, %{{.*}}
// CHECK: gpu.launch
// CHECK-SAME: blocks(%i0, %i1, %i2) in (%i6 = %[[range_i]], %i7 = %c1, %i8 = %c1)
// CHECK-SAME: threads(%i3, %i4, %i5) in (%i9 = %[[range_j]], %i10 = %c1, %i11 = %c1)
// CHECK-SAME: blocks(%{{[^)]*}}, %{{[^)]*}}, %{{[^)]*}}) in (%{{[^)]*}} = %[[range_i]], %{{[^)]*}} = %{{[^)]*}}, %{{[^)]*}} = %{{[^)]*}})
// CHECK-SAME: threads(%{{[^)]*}}, %{{[^)]*}}, %{{[^)]*}}) in (%{{[^)]*}} = %[[range_j]], %{{[^)]*}} = %{{[^)]*}}, %{{[^)]*}} = %{{[^)]*}})
affine.for %i = 5 to 15 step 4 {
affine.for %j = 3 to 19 step 7 {
// Loop induction variable remapping:
// iv = thread(block)_id * step + lower_bound
// CHECK: %[[prod_i:.*]] = muli %i16, %i0 : index
// CHECK-NEXT: %[[i:.*]] = addi %i14, %[[prod_i]] : index
// CHECK-NEXT: %[[prod_j:.*]] = muli %i17, %i3 : index
// CHECK-NEXT: %[[j:.*]] = addi %i15, %[[prod_j]] : index
// CHECK: %[[prod_i:.*]] = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %[[i:.*]] = addi %{{.*}}, %[[prod_i]] : index
// CHECK-NEXT: %[[prod_j:.*]] = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %[[j:.*]] = addi %{{.*}}, %[[prod_j]] : index
// CHECK: {{.*}} = load %i12[%[[i]], %[[j]]] : memref<?x?xf32>
// CHECK: {{.*}} = load %{{.*}}[%[[i]], %[[j]]] : memref<?x?xf32>
%0 = load %A[%i, %j] : memref<?x?xf32>
// CHECK: store {{.*}}, %i13[%[[i]], %[[j]]] : memref<?x?xf32>
// CHECK: store {{.*}}, %{{.*}}[%[[i]], %[[j]]] : memref<?x?xf32>
store %0, %B[%i, %j] : memref<?x?xf32>
}
}

176
mlir/test/EDSC/builder-api-test.cpp
View File

@ -81,15 +81,15 @@ TEST_FUNC(builder_dynamic_for_func_args) {
});
// clang-format off
// CHECK-LABEL: func @builder_dynamic_for_func_args(%arg0: index, %arg1: index) {
// CHECK: affine.for %i0 = (d0) -> (d0)(%arg0) to (d0) -> (d0)(%arg1) step 3 {
// CHECK: {{.*}} = affine.apply ()[s0] -> (s0 * 3)()[%arg0]
// CHECK: {{.*}} = affine.apply ()[s0, s1] -> (s1 + s0 * 3)()[%arg0, %arg1]
// CHECK: {{.*}} = affine.apply ()[s0] -> (s0 + 3)()[%arg0]
// CHECK: affine.for %i1 = (d0) -> (d0)(%arg0) to (d0) -> (d0)(%arg1) step 2 {
// CHECK: {{.*}} = affine.apply (d0, d1) -> ((d0 + d1 * 3) floordiv 32)(%i0, %i1)
// CHECK: {{.*}} = affine.apply (d0, d1) -> (((d0 + d1 * 3) floordiv 32) * 31)(%i0, %i1)
// CHECK: {{.*}} = affine.apply (d0, d1) -> ((((d0 + d1 * 3) floordiv 32) * 31) ceildiv 32)(%i0, %i1)
// CHECK-LABEL: func @builder_dynamic_for_func_args(%{{.*}}: index, %{{.*}}: index) {
// CHECK: affine.for %{{.*}} = (d0) -> (d0)(%{{.*}}) to (d0) -> (d0)(%{{.*}}) step 3 {
// CHECK: {{.*}} = affine.apply ()[s0] -> (s0 * 3)()[%{{.*}}]
// CHECK: {{.*}} = affine.apply ()[s0, s1] -> (s1 + s0 * 3)()[%{{.*}}, %{{.*}}]
// CHECK: {{.*}} = affine.apply ()[s0] -> (s0 + 3)()[%{{.*}}]
// CHECK: affine.for %{{.*}} = (d0) -> (d0)(%{{.*}}) to (d0) -> (d0)(%{{.*}}) step 2 {
// CHECK: {{.*}} = affine.apply (d0, d1) -> ((d0 + d1 * 3) floordiv 32)(%{{.*}}, %{{.*}})
// CHECK: {{.*}} = affine.apply (d0, d1) -> (((d0 + d1 * 3) floordiv 32) * 31)(%{{.*}}, %{{.*}})
// CHECK: {{.*}} = affine.apply (d0, d1) -> ((((d0 + d1 * 3) floordiv 32) * 31) ceildiv 32)(%{{.*}}, %{{.*}})
// CHECK-DAG: [[rf1:%[0-9]+]] = addf {{.*}}, {{.*}} : f32
// CHECK-DAG: [[rf2:%[0-9]+]] = divf [[rf1]], {{.*}} : f32
// CHECK-DAG: [[rf3:%[0-9]+]] = remf [[rf2]], {{.*}} : f32
@ -120,10 +120,10 @@ TEST_FUNC(builder_dynamic_for) {
LoopBuilder(&i, a - b, c + d, 2)();
// clang-format off
// CHECK-LABEL: func @builder_dynamic_for(%arg0: index, %arg1: index, %arg2: index, %arg3: index) {
// CHECK-DAG: [[r0:%[0-9]+]] = affine.apply ()[s0, s1] -> (s0 - s1)()[%arg0, %arg1]
// CHECK-DAG: [[r1:%[0-9]+]] = affine.apply ()[s0, s1] -> (s0 + s1)()[%arg2, %arg3]
// CHECK-NEXT: affine.for %i0 = (d0) -> (d0)([[r0]]) to (d0) -> (d0)([[r1]]) step 2 {
// CHECK-LABEL: func @builder_dynamic_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK-DAG: [[r0:%[0-9]+]] = affine.apply ()[s0, s1] -> (s0 - s1)()[%{{.*}}, %{{.*}}]
// CHECK-DAG: [[r1:%[0-9]+]] = affine.apply ()[s0, s1] -> (s0 + s1)()[%{{.*}}, %{{.*}}]
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)([[r0]]) to (d0) -> (d0)([[r1]]) step 2 {
// clang-format on
f.print(llvm::outs());
f.erase();
@ -145,8 +145,8 @@ TEST_FUNC(builder_max_min_for) {
ret();
// clang-format off
// CHECK-LABEL: func @builder_max_min_for(%arg0: index, %arg1: index, %arg2: index, %arg3: index) {
// CHECK: affine.for %i0 = max (d0, d1) -> (d0, d1)(%arg0, %arg1) to min (d0, d1) -> (d0, d1)(%arg2, %arg3) {
// CHECK-LABEL: func @builder_max_min_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK: affine.for %{{.*}} = max (d0, d1) -> (d0, d1)(%{{.*}}, %{{.*}}) to min (d0, d1) -> (d0, d1)(%{{.*}}, %{{.*}}) {
// CHECK: return
// clang-format on
f.print(llvm::outs());
@ -184,14 +184,14 @@ TEST_FUNC(builder_blocks) {
// clang-format off
// CHECK-LABEL: @builder_blocks
// CHECK: %c42_i32 = constant 42 : i32
// CHECK-NEXT: %c1234_i32 = constant 1234 : i32
// CHECK-NEXT: br ^bb1(%c42_i32, %c1234_i32 : i32, i32)
// CHECK-NEXT: ^bb1(%0: i32, %1: i32): // 2 preds: ^bb0, ^bb2
// CHECK-NEXT: %2 = addi %0, %1 : i32
// CHECK-NEXT: br ^bb2(%0, %2 : i32, i32)
// CHECK-NEXT: ^bb2(%3: i32, %4: i32): // pred: ^bb1
// CHECK-NEXT: br ^bb1(%3, %4 : i32, i32)
// CHECK: %{{.*}} = constant 42 : i32
// CHECK-NEXT: %{{.*}} = constant 1234 : i32
// CHECK-NEXT: br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
// CHECK-NEXT: ^bb1(%{{.*}}: i32, %{{.*}}: i32): // 2 preds: ^bb0, ^bb2
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : i32
// CHECK-NEXT: br ^bb2(%{{.*}}, %{{.*}} : i32, i32)
// CHECK-NEXT: ^bb2(%{{.*}}: i32, %{{.*}}: i32): // pred: ^bb1
// CHECK-NEXT: br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
// CHECK-NEXT: }
// clang-format on
f.print(llvm::outs());
@ -228,14 +228,14 @@ TEST_FUNC(builder_blocks_eager) {
}
// CHECK-LABEL: @builder_blocks_eager
// CHECK: %c42_i32 = constant 42 : i32
// CHECK-NEXT: %c1234_i32 = constant 1234 : i32
// CHECK-NEXT: br ^bb1(%c42_i32, %c1234_i32 : i32, i32)
// CHECK-NEXT: ^bb1(%0: i32, %1: i32): // 2 preds: ^bb0, ^bb2
// CHECK-NEXT: %2 = addi %0, %1 : i32
// CHECK-NEXT: br ^bb2(%0, %2 : i32, i32)
// CHECK-NEXT: ^bb2(%3: i32, %4: i32): // pred: ^bb1
// CHECK-NEXT: br ^bb1(%3, %4 : i32, i32)
// CHECK: %{{.*}} = constant 42 : i32
// CHECK-NEXT: %{{.*}} = constant 1234 : i32
// CHECK-NEXT: br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
// CHECK-NEXT: ^bb1(%{{.*}}: i32, %{{.*}}: i32): // 2 preds: ^bb0, ^bb2
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : i32
// CHECK-NEXT: br ^bb2(%{{.*}}, %{{.*}} : i32, i32)
// CHECK-NEXT: ^bb2(%{{.*}}: i32, %{{.*}}: i32): // pred: ^bb1
// CHECK-NEXT: br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
// CHECK-NEXT: }
// clang-format on
f.print(llvm::outs());
@ -266,13 +266,13 @@ TEST_FUNC(builder_cond_branch) {
// clang-format off
// CHECK-LABEL: @builder_cond_branch
// CHECK: %c32_i32 = constant 32 : i32
// CHECK-NEXT: %c64_i64 = constant 64 : i64
// CHECK-NEXT: %c42_i32 = constant 42 : i32
// CHECK-NEXT: cond_br %arg0, ^bb1(%c32_i32 : i32), ^bb2(%c64_i64, %c42_i32 : i64, i32)
// CHECK-NEXT: ^bb1(%0: i32): // pred: ^bb0
// CHECK: %{{.*}} = constant 32 : i32
// CHECK-NEXT: %{{.*}} = constant 64 : i64
// CHECK-NEXT: %{{.*}} = constant 42 : i32
// CHECK-NEXT: cond_br %{{.*}}, ^bb1(%{{.*}} : i32), ^bb2(%{{.*}}, %{{.*}} : i64, i32)
// CHECK-NEXT: ^bb1(%{{.*}}: i32): // pred: ^bb0
// CHECK-NEXT: return
// CHECK-NEXT: ^bb2(%1: i64, %2: i32): // pred: ^bb0
// CHECK-NEXT: ^bb2(%{{.*}}: i64, %{{.*}}: i32): // pred: ^bb0
// CHECK-NEXT: return
// clang-format on
f.print(llvm::outs());
@ -305,13 +305,13 @@ TEST_FUNC(builder_cond_branch_eager) {
});
// CHECK-LABEL: @builder_cond_branch_eager
// CHECK: %c32_i32 = constant 32 : i32
// CHECK-NEXT: %c64_i64 = constant 64 : i64
// CHECK-NEXT: %c42_i32 = constant 42 : i32
// CHECK-NEXT: cond_br %arg0, ^bb1(%c32_i32 : i32), ^bb2(%c64_i64, %c42_i32 : i64, i32)
// CHECK-NEXT: ^bb1(%0: i32): // pred: ^bb0
// CHECK: %{{.*}} = constant 32 : i32
// CHECK-NEXT: %{{.*}} = constant 64 : i64
// CHECK-NEXT: %{{.*}} = constant 42 : i32
// CHECK-NEXT: cond_br %{{.*}}, ^bb1(%{{.*}} : i32), ^bb2(%{{.*}}, %{{.*}} : i64, i32)
// CHECK-NEXT: ^bb1(%{{.*}}: i32): // pred: ^bb0
// CHECK-NEXT: return
// CHECK-NEXT: ^bb2(%1: i64, %2: i32): // pred: ^bb0
// CHECK-NEXT: ^bb2(%{{.*}}: i64, %{{.*}}: i32): // pred: ^bb0
// CHECK-NEXT: return
// clang-format on
f.print(llvm::outs());
@ -352,22 +352,22 @@ TEST_FUNC(builder_helpers) {
});
// CHECK-LABEL: @builder_helpers
// CHECK: affine.for %i0 = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
// CHECK-NEXT: affine.for %i1 = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
// CHECK-NEXT: affine.for %i2 = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
// CHECK-DAG: [[a:%.*]] = load %arg0[%i0, %i1, %i2] : memref<?x?x?xf32>
// CHECK: affine.for %{{.*}} = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)({{.*}}) to (d0) -> (d0)({{.*}}) {
// CHECK-DAG: [[a:%.*]] = load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-DAG: [[b:%.*]] = addf {{.*}}, [[a]] : f32
// CHECK-DAG: [[c:%.*]] = load %arg1[%i0, %i1, %i2] : memref<?x?x?xf32>
// CHECK-DAG: [[c:%.*]] = load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-DAG: [[d:%.*]] = addf [[b]], [[c]] : f32
// CHECK-NEXT: store [[d]], %arg2[%i0, %i1, %i2] : memref<?x?x?xf32>
// CHECK-NEXT: store [[d]], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-NEXT: }
// CHECK-NEXT: affine.for %i3 = (d0) -> (d0)(%c0_1) to (d0) -> (d0)(%2) {
// CHECK-DAG: [[a:%.*]] = load %arg1[%i0, %i1, %i3] : memref<?x?x?xf32>
// CHECK-DAG: [[b:%.*]] = load %arg0[%i0, %i1, %i3] : memref<?x?x?xf32>
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)(%{{.*}}) to (d0) -> (d0)(%{{.*}}) {
// CHECK-DAG: [[a:%.*]] = load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-DAG: [[b:%.*]] = load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-DAG: [[c:%.*]] = addf [[b]], [[a]] : f32
// CHECK-DAG: [[d:%.*]] = load %arg2[%i0, %i1, %i3] : memref<?x?x?xf32>
// CHECK-DAG: [[d:%.*]] = load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-DAG: [[e:%.*]] = addf [[d]], [[c]] : f32
// CHECK-NEXT: store [[e]], %arg2[%i0, %i1, %i3] : memref<?x?x?xf32>
// CHECK-NEXT: store [[e]], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// clang-format on
f.print(llvm::outs());
f.erase();
@ -402,8 +402,8 @@ TEST_FUNC(custom_ops) {
});
// CHECK-LABEL: @custom_ops
// CHECK: affine.for %i0 {{.*}}
// CHECK: affine.for %i1 {{.*}}
// CHECK: affine.for %{{.*}} {{.*}}
// CHECK: affine.for %{{.*}} {{.*}}
// CHECK: {{.*}} = "my_custom_op"{{.*}} : (index, index) -> index
// CHECK: "my_custom_op_0"{{.*}} : (index, index) -> ()
// CHECK: [[TWO:%[a-z0-9]+]]:2 = "my_custom_op_2"{{.*}} : (index, index) -> (index, index)
@ -463,8 +463,8 @@ TEST_FUNC(select_op) {
});
// CHECK-LABEL: @select_op
// CHECK: affine.for %i0 = 0 to 1 {
// CHECK-NEXT: affine.for %i1 = 0 to 1 {
// CHECK: affine.for %{{.*}} = 0 to 1 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1 {
// CHECK-DAG: {{.*}} = cmpi "eq"
// CHECK-DAG: {{.*}} = load
// CHECK-DAG: {{.*}} = load
@ -516,29 +516,29 @@ TEST_FUNC(tile_2d) {
// CHECK: %[[M:[0-9]+]] = dim %arg2, 0 : memref<?x?x?xf32>
// CHECK-NEXT: %[[N:[0-9]+]] = dim %arg2, 1 : memref<?x?x?xf32>
// CHECK-NEXT: %[[P:[0-9]+]] = dim %arg2, 2 : memref<?x?x?xf32>
// CHECK: affine.for %i0 = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[M]]) step 512 {
// CHECK-NEXT: affine.for %i1 = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[N]]) step 1024 {
// CHECK-NEXT: affine.for %i2 = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[P]]) {
// CHECK-NEXT: affine.for %i3 = max (d0)[s0] -> (s0, d0)(%i0)[%[[ZERO]]] to min (d0)[s0] -> (s0, d0 + 512)(%i0)[%[[M]]] step 16 {
// CHECK-NEXT: affine.for %i4 = max (d0)[s0] -> (s0, d0)(%i1)[%[[ZERO]]] to min (d0)[s0] -> (s0, d0 + 1024)(%i1)[%[[N]]] step 32 {
// CHECK-NEXT: affine.for %i5 = max (d0, d1)[s0] -> (s0, d0, d1)(%i1, %i4)[%[[ZERO]]] to min (d0, d1)[s0] -> (s0, d0 + 1024, d1 + 32)(%i1, %i4)[%[[N]]] {
// CHECK-NEXT: affine.for %i6 = max (d0, d1)[s0] -> (s0, d0, d1)(%i0, %i3)[%[[ZERO]]] to min (d0, d1)[s0] -> (s0, d0 + 512, d1 + 16)(%i0, %i3)[%[[M]]] {
// CHECK-NEXT: {{.*}} = load {{.*}}[%i6, %i5, %i2] : memref<?x?x?xf32>
// CHECK-NEXT: {{.*}} = load {{.*}}[%i6, %i5, %i2] : memref<?x?x?xf32>
// CHECK: affine.for %{{.*}} = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[M]]) step 512 {
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[N]]) step 1024 {
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[P]]) {
// CHECK-NEXT: affine.for %{{.*}} = max (d0)[s0] -> (s0, d0)(%{{.*}})[%[[ZERO]]] to min (d0)[s0] -> (s0, d0 + 512)(%{{.*}})[%[[M]]] step 16 {
// CHECK-NEXT: affine.for %{{.*}} = max (d0)[s0] -> (s0, d0)(%{{.*}})[%[[ZERO]]] to min (d0)[s0] -> (s0, d0 + 1024)(%{{.*}})[%[[N]]] step 32 {
// CHECK-NEXT: affine.for %{{.*}} = max (d0, d1)[s0] -> (s0, d0, d1)(%{{.*}}, %{{.*}})[%[[ZERO]]] to min (d0, d1)[s0] -> (s0, d0 + 1024, d1 + 32)(%{{.*}}, %{{.*}})[%[[N]]] {
// CHECK-NEXT: affine.for %{{.*}} = max (d0, d1)[s0] -> (s0, d0, d1)(%{{.*}}, %{{.*}})[%[[ZERO]]] to min (d0, d1)[s0] -> (s0, d0 + 512, d1 + 16)(%{{.*}}, %{{.*}})[%[[M]]] {
// CHECK-NEXT: {{.*}} = load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-NEXT: {{.*}} = load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-NEXT: {{.*}} = addf {{.*}}, {{.*}} : f32
// CHECK-NEXT: store {{.*}}, {{.*}}[%i6, %i5, %i2] : memref<?x?x?xf32>
// CHECK-NEXT: store {{.*}}, {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: affine.for %i7 = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[P]]) {
// CHECK-NEXT: affine.for %i8 = max (d0)[s0] -> (s0, d0)(%i0)[%[[ZERO]]] to min (d0)[s0] -> (s0, d0 + 512)(%i0)[%[[M]]] {
// CHECK-NEXT: affine.for %i9 = max (d0)[s0] -> (s0, d0)(%i1)[%[[ZERO]]] to min (d0)[s0] -> (s0, d0 + 1024)(%i1)[%[[N]]] {
// CHECK-NEXT: {{.*}} = load {{.*}}[%i8, %i9, %i7] : memref<?x?x?xf32>
// CHECK-NEXT: {{.*}} = load {{.*}}[%i8, %i9, %i7] : memref<?x?x?xf32>
// CHECK-NEXT: affine.for %{{.*}} = (d0) -> (d0)(%[[ZERO]]) to (d0) -> (d0)(%[[P]]) {
// CHECK-NEXT: affine.for %{{.*}} = max (d0)[s0] -> (s0, d0)(%{{.*}})[%[[ZERO]]] to min (d0)[s0] -> (s0, d0 + 512)(%{{.*}})[%[[M]]] {
// CHECK-NEXT: affine.for %{{.*}} = max (d0)[s0] -> (s0, d0)(%{{.*}})[%[[ZERO]]] to min (d0)[s0] -> (s0, d0 + 1024)(%{{.*}})[%[[N]]] {
// CHECK-NEXT: {{.*}} = load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-NEXT: {{.*}} = load {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// CHECK-NEXT: {{.*}}= addf {{.*}}, {{.*}} : f32
// CHECK-NEXT: store {{.*}}, {{.*}}[%i8, %i9, %i7] : memref<?x?x?xf32>
// CHECK-NEXT: store {{.*}}, {{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<?x?x?xf32>
// clang-format on
f.print(llvm::outs());
f.erase();
@ -575,21 +575,21 @@ TEST_FUNC(vectorize_2d) {
ret();
// xCHECK-LABEL: func @vectorize_2d
// xCHECK-NEXT: %[[M:.*]] = dim %arg0, 0 : memref<?x?x?xf32>
// xCHECK-NEXT: %[[N:.*]] = dim %arg0, 1 : memref<?x?x?xf32>
// xCHECK-NEXT: %[[P:.*]] = dim %arg0, 2 : memref<?x?x?xf32>
// xCHECK-NEXT: affine.for %i0 = 0 to (d0) -> (d0)(%[[M]]) {
// xCHECK-NEXT: affine.for %i1 = 0 to (d0) -> (d0)(%[[N]]) step 4 {
// xCHECK-NEXT: affine.for %i2 = 0 to (d0) -> (d0)(%[[P]]) step 4 {
// xCHECK-NEXT: %[[vA:.*]] = "vector.transfer_read"(%arg1, %i0, %i1,
%i2) {permutation_map = (d0, d1, d2) -> (d1, d2)} : (memref<?x?x?xf32>, index,
index, index) -> vector<4x4xf32>
// xCHECK-NEXT: %[[vB:.*]] = "vector.transfer_read"(%arg0, %i0, %i1,
%i2) {permutation_map = (d0, d1, d2) -> (d1, d2)} : (memref<?x?x?xf32>, index,
index, index) -> vector<4x4xf32>
// xCHECK-NEXT: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?x?xf32>
// xCHECK-NEXT: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?x?xf32>
// xCHECK-NEXT: %[[P:.*]] = dim %{{.*}}, 2 : memref<?x?x?xf32>
// xCHECK-NEXT: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[M]]) {
// xCHECK-NEXT: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[N]]) step 4 {
// xCHECK-NEXT: affine.for %{{.*}} = 0 to (d0) -> (d0)(%[[P]]) step 4 {
// xCHECK-NEXT: %[[vA:.*]] = "vector.transfer_read"(%{{.*}}, %{{.*}},
%{{.*}}, %i2) {permutation_map = (d0, d1, d2) -> (d1, d2)} : (memref<?x?x?xf32>,
index, index, index) -> vector<4x4xf32>
// xCHECK-NEXT: %[[vB:.*]] = "vector.transfer_read"(%{{.*}}, %{{.*}},
%{{.*}}, %i2) {permutation_map = (d0, d1, d2) -> (d1, d2)} :
(memref<?x?x?xf32>, index, index, index) -> vector<4x4xf32>
// xCHECK-NEXT: %[[vRES:.*]] = addf %[[vB]], %[[vA]] : vector<4x4xf32>
// xCHECK-NEXT: "vector.transfer_write"(%[[vRES:.*]], %arg2, %i0, %i1,
%i2) {permutation_map = (d0, d1, d2) -> (d1, d2)} : (vector<4x4xf32>,
// xCHECK-NEXT: "vector.transfer_write"(%[[vRES:.*]], %{{.*}}, %{{.*}},
%{{.*}}, %i2) {permutation_map = (d0, d1, d2) -> (d1, d2)} : (vector<4x4xf32>,
memref<?x?x?xf32>, index, index, index) -> ()
// clang-format on

22
mlir/test/Examples/Linalg/Linalg1.mlir
View File

@ -36,17 +36,17 @@ func @slice_op(%arg0: memref<?x?xf32>) {
}
return
}
// CHECK-LABEL: func @slice_op(%arg0: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %arg0, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %arg0, 1 : memref<?x?xf32>
// CHECK: %[[r1:.*]] = linalg.range %c0:%[[M]]:%c1 : !linalg.range
// CHECK: %[[r2:.*]] = linalg.range %c0:%[[N]]:%c1 : !linalg.range
// CHECK: %[[V:.*]] = linalg.view %arg0[%[[r1]], %[[r2]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: affine.for %i0 = 0 to #map1(%0) {
// CHECK: affine.for %i1 = 0 to #map1(%1) {
// CHECK: {{.*}} = linalg.slice %[[V]][%i0] {dim = 1} : !linalg.view<?x?xf32>, index
// CHECK: %[[V2:.*]] = linalg.slice %[[V]][%i1] {dim = 0} : !linalg.view<?x?xf32>, index
// CHECK: {{.*}} = linalg.slice %[[V2]][%i0] {dim = 0} : !linalg.view<?xf32>, index
// CHECK-LABEL: func @slice_op(%{{.*}}: memref<?x?xf32>) {
// CHECK: %[[M:.*]] = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK: %[[N:.*]] = dim %{{.*}}, 1 : memref<?x?xf32>
// CHECK: %[[r1:.*]] = linalg.range %{{.*}}:%[[M]]:%{{.*}} : !linalg.range
// CHECK: %[[r2:.*]] = linalg.range %{{.*}}:%[[N]]:%{{.*}} : !linalg.range
// CHECK: %[[V:.*]] = linalg.view %{{.*}}[%[[r1]], %[[r2]]] : memref<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK: affine.for %{{.*}} = 0 to #map1(%{{.*}}) {
// CHECK: affine.for %{{.*}} = 0 to #map1(%{{.*}}) {
// CHECK: {{.*}} = linalg.slice %[[V]][%{{.*}}] {dim = 1} : !linalg.view<?x?xf32>, index
// CHECK: %[[V2:.*]] = linalg.slice %[[V]][%{{.*}}] {dim = 0} : !linalg.view<?x?xf32>, index
// CHECK: {{.*}} = linalg.slice %[[V2]][%{{.*}}] {dim = 0} : !linalg.view<?xf32>, index
func @rangeConversion(%arg0: index, %arg1: index, %arg2: index) {
%0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range

22
mlir/test/GPU/ops.mlir
View File

@ -1,8 +1,8 @@
// RUN: mlir-opt %s | FileCheck %s
// CHECK-LABEL:func @no_args(%arg0: index)
// CHECK-LABEL:func @no_args(%{{.*}}: index)
func @no_args(%sz : index) {
// CHECK: gpu.launch blocks(%i0, %i1, %i2) in (%i6 = %arg0, %i7 = %arg0, %i8 = %arg0) threads(%i3, %i4, %i5) in (%i9 = %arg0, %i10 = %arg0, %i11 = %arg0)
// CHECK: gpu.launch blocks(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) threads(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}})
gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %sz, %grid_y = %sz, %grid_z = %sz)
threads(%tx, %ty, %tz) in (%block_x = %sz, %block_y = %sz, %block_z = %sz) {
// CHECK: gpu.return
@ -11,9 +11,9 @@ func @no_args(%sz : index) {
return
}
// CHECK-LABEL:func @args(%arg0: index, %arg1: index, %arg2: f32, %arg3: memref<?xf32, 1>) {
// CHECK-LABEL:func @args(%{{.*}}: index, %{{.*}}: index, %{{.*}}: f32, %{{.*}}: memref<?xf32, 1>) {
func @args(%blk : index, %thrd : index, %float : f32, %data : memref<?xf32,1>) {
// CHECK: gpu.launch blocks(%i0, %i1, %i2) in (%i6 = %arg0, %i7 = %arg0, %i8 = %arg0) threads(%i3, %i4, %i5) in (%i9 = %arg1, %i10 = %arg1, %i11 = %arg1) args(%i12 = %arg2, %i13 = %arg3) : f32, memref<?xf32, 1>
// CHECK: gpu.launch blocks(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) threads(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) args(%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) : f32, memref<?xf32, 1>
gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %blk, %grid_y = %blk, %grid_z = %blk)
threads(%tx, %ty, %tz) in (%block_x = %thrd, %block_y = %thrd, %block_z = %thrd)
args(%kernel_arg0 = %float, %kernel_arg1 = %data) : f32, memref<?xf32, 1> {
@ -26,11 +26,11 @@ func @args(%blk : index, %thrd : index, %float : f32, %data : memref<?xf32,1>) {
// It is possible to use values passed into the region as arguments.
// CHECK-LABEL: func @passing_values
func @passing_values(%blk : index, %thrd : index, %float : f32, %data : memref<?xf32,1>) {
// CHECK: gpu.launch blocks(%i0, %i1, %i2) in (%i6 = %arg0, %i7 = %arg0, %i8 = %arg0) threads(%i3, %i4, %i5) in (%i9 = %arg1, %i10 = %arg1, %i11 = %arg1) args(%i12 = %arg2, %i13 = %arg3) : f32, memref<?xf32, 1>
// CHECK: gpu.launch blocks(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) threads(%{{.*}}, %{{.*}}, %{{.*}}) in (%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) args(%{{.*}} = %{{.*}}, %{{.*}} = %{{.*}}) : f32, memref<?xf32, 1>
gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %blk, %grid_y = %blk, %grid_z = %blk)
threads(%tx, %ty, %tz) in (%block_x = %thrd, %block_y = %thrd, %block_z = %thrd)
args(%kernel_arg0 = %float, %kernel_arg1 = %data) : f32, memref<?xf32, 1> {
// CHECK: "use"(%i12)
// CHECK: "use"(%{{.*}})
"use"(%kernel_arg0): (f32) -> ()
// CHECK: gpu.return
gpu.return
@ -45,10 +45,10 @@ func @nested_isolation(%sz : index) {
gpu.launch blocks(%bx, %by, %bz) in (%grid_x = %sz, %grid_y = %sz, %grid_z = %sz)
threads(%tx, %ty, %tz) in (%block_x = %sz, %block_y = %sz, %block_z = %sz) {
"region"() ({
// CHECK: %0 = "produce"()
// CHECK: %{{.*}} = "produce"()
%val = "produce"() : () -> (index)
"region"() ({
// CHECK: "use"(%0)
// CHECK: "use"(%{{.*}})
"use"(%val) : (index) -> ()
}) : () -> ()
}) : () -> ()
@ -87,14 +87,14 @@ func @kernel_2(f32, memref<?xf32, 1>)
func @foo() {
%0 = "op"() : () -> (f32)
%1 = "op"() : () -> (memref<?xf32, 1>)
// CHECK: %c8 = constant 8
// CHECK: %{{.*}} = constant 8
%cst = constant 8 : index
// CHECK: "gpu.launch_func"(%c8, %c8, %c8, %c8, %c8, %c8, %0, %1) {kernel = @kernel_1} : (index, index, index, index, index, index, f32, memref<?xf32, 1>) -> ()
// CHECK: "gpu.launch_func"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) {kernel = @kernel_1} : (index, index, index, index, index, index, f32, memref<?xf32, 1>) -> ()
"gpu.launch_func"(%cst, %cst, %cst, %cst, %cst, %cst, %0, %1) { kernel = @kernel_1 }
: (index, index, index, index, index, index, f32, memref<?xf32, 1>) -> ()
// CHECK: "gpu.launch_func"(%c8, %c8, %c8, %c8, %c8, %c8, %0, %1) {kernel = @kernel_2} : (index, index, index, index, index, index, f32, memref<?xf32, 1>) -> ()
// CHECK: "gpu.launch_func"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) {kernel = @kernel_2} : (index, index, index, index, index, index, f32, memref<?xf32, 1>) -> ()
"gpu.launch_func"(%cst, %cst, %cst, %cst, %cst, %cst, %0, %1) { kernel = @kernel_2 }
: (index, index, index, index, index, index, f32, memref<?xf32, 1>) -> ()

24
mlir/test/IR/core-ops.mlir
View File

@ -438,13 +438,13 @@ func @std_for(%arg0 : index, %arg1 : index, %arg2 : index) {
return
}
// CHECK-LABEL: func @std_for(
// CHECK-NEXT: for %i0 = %arg0 to %arg1 step %arg2 {
// CHECK-NEXT: for %i1 = %arg0 to %arg1 step %arg2 {
// CHECK-NEXT: %0 = cmpi "slt", %i0, %i1 : index
// CHECK-NEXT: %1 = select %0, %i0, %i1 : index
// CHECK-NEXT: %2 = cmpi "sge", %i0, %i1 : index
// CHECK-NEXT: %3 = select %2, %i0, %i1 : index
// CHECK-NEXT: for %i2 = %1 to %3 step %i1 {
// CHECK-NEXT: for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK-NEXT: for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
func @std_if(%arg0: i1, %arg1: f32) {
if %arg0 {
@ -453,8 +453,8 @@ func @std_if(%arg0: i1, %arg1: f32) {
return
}
// CHECK-LABEL: func @std_if(
// CHECK-NEXT: if %arg0 {
// CHECK-NEXT: %{{.*}} = addf %arg1, %arg1 : f32
// CHECK-NEXT: if %{{.*}} {
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
func @std_if_else(%arg0: i1, %arg1: f32) {
if %arg0 {
@ -465,7 +465,7 @@ func @std_if_else(%arg0: i1, %arg1: f32) {
return
}
// CHECK-LABEL: func @std_if_else(
// CHECK-NEXT: if %arg0 {
// CHECK-NEXT: %{{.*}} = addf %arg1, %arg1 : f32
// CHECK-NEXT: if %{{.*}} {
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: } else {
// CHECK-NEXT: %{{.*}} = addf %arg1, %arg1 : f32
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32

204
mlir/test/IR/parser.mlir
View File

@ -135,21 +135,21 @@ func @complex_types(complex<i1>) -> complex<f32>
// CHECK: func @functions((memref<1x?x4x?x?xi32, #map0>, memref<8xi8>) -> (), () -> ())
func @functions((memref<1x?x4x?x?xi32, #map0, 0>, memref<8xi8, #map1, 0>) -> (), ()->())
// CHECK-LABEL: func @simpleCFG(%arg0: i32, %arg1: f32) -> i1 {
// CHECK-LABEL: func @simpleCFG(%{{.*}}: i32, %{{.*}}: f32) -> i1 {
func @simpleCFG(%arg0: i32, %f: f32) -> i1 {
// CHECK: %0 = "foo"() : () -> i64
// CHECK: %{{.*}} = "foo"() : () -> i64
%1 = "foo"() : ()->i64
// CHECK: "bar"(%0) : (i64) -> (i1, i1, i1)
// CHECK: "bar"(%{{.*}}) : (i64) -> (i1, i1, i1)
%2:3 = "bar"(%1) : (i64) -> (i1,i1,i1)
// CHECK: return %1#1
// CHECK: return %{{.*}}#1
return %2#1 : i1
// CHECK: }
}
// CHECK-LABEL: func @simpleCFGUsingBBArgs(%arg0: i32, %arg1: i64) {
// CHECK-LABEL: func @simpleCFGUsingBBArgs(%{{.*}}: i32, %{{.*}}: i64) {
func @simpleCFGUsingBBArgs(i32, i64) {
^bb42 (%arg0: i32, %f: i64):
// CHECK: "bar"(%arg1) : (i64) -> (i1, i1, i1)
// CHECK: "bar"(%{{.*}}) : (i64) -> (i1, i1, i1)
%2:3 = "bar"(%f) : (i64) -> (i1,i1,i1)
// CHECK: return{{$}}
return
@ -172,51 +172,51 @@ func @emptyMLF() {
return // CHECK: return
} // CHECK: }
// CHECK-LABEL: func @func_with_one_arg(%arg0: i1) -> i2 {
// CHECK-LABEL: func @func_with_one_arg(%{{.*}}: i1) -> i2 {
func @func_with_one_arg(%c : i1) -> i2 {
// CHECK: %0 = "foo"(%arg0) : (i1) -> i2
// CHECK: %{{.*}} = "foo"(%{{.*}}) : (i1) -> i2
%b = "foo"(%c) : (i1) -> (i2)
return %b : i2 // CHECK: return %0 : i2
return %b : i2 // CHECK: return %{{.*}} : i2
} // CHECK: }
// CHECK-LABEL: func @func_with_two_args(%arg0: f16, %arg1: i8) -> (i1, i32) {
// CHECK-LABEL: func @func_with_two_args(%{{.*}}: f16, %{{.*}}: i8) -> (i1, i32) {
func @func_with_two_args(%a : f16, %b : i8) -> (i1, i32) {
// CHECK: %0:2 = "foo"(%arg0, %arg1) : (f16, i8) -> (i1, i32)
// CHECK: %{{.*}}:2 = "foo"(%{{.*}}, %{{.*}}) : (f16, i8) -> (i1, i32)
%c:2 = "foo"(%a, %b) : (f16, i8)->(i1, i32)
return %c#0, %c#1 : i1, i32 // CHECK: return %0#0, %0#1 : i1, i32
return %c#0, %c#1 : i1, i32 // CHECK: return %{{.*}}#0, %{{.*}}#1 : i1, i32
} // CHECK: }
// CHECK-LABEL: func @second_order_func() -> (() -> ()) {
func @second_order_func() -> (() -> ()) {
// CHECK-NEXT: %f = constant @emptyMLF : () -> ()
// CHECK-NEXT: %{{.*}} = constant @emptyMLF : () -> ()
%c = constant @emptyMLF : () -> ()
// CHECK-NEXT: return %f : () -> ()
// CHECK-NEXT: return %{{.*}} : () -> ()
return %c : () -> ()
}
// CHECK-LABEL: func @third_order_func() -> (() -> (() -> ())) {
func @third_order_func() -> (() -> (() -> ())) {
// CHECK-NEXT: %f = constant @second_order_func : () -> (() -> ())
// CHECK-NEXT: %{{.*}} = constant @second_order_func : () -> (() -> ())
%c = constant @second_order_func : () -> (() -> ())
// CHECK-NEXT: return %f : () -> (() -> ())
// CHECK-NEXT: return %{{.*}} : () -> (() -> ())
return %c : () -> (() -> ())
}
// CHECK-LABEL: func @identity_functor(%arg0: () -> ()) -> (() -> ()) {
// CHECK-LABEL: func @identity_functor(%{{.*}}: () -> ()) -> (() -> ()) {
func @identity_functor(%a : () -> ()) -> (() -> ()) {
// CHECK-NEXT: return %arg0 : () -> ()
// CHECK-NEXT: return %{{.*}} : () -> ()
return %a : () -> ()
}
// CHECK-LABEL: func @func_ops_in_loop() {
func @func_ops_in_loop() {
// CHECK: %0 = "foo"() : () -> i64
// CHECK: %{{.*}} = "foo"() : () -> i64
%a = "foo"() : ()->i64
// CHECK: affine.for %i0 = 1 to 10 {
// CHECK: affine.for %{{.*}} = 1 to 10 {
affine.for %i = 1 to 10 {
// CHECK: %1 = "doo"() : () -> f32
// CHECK: %{{.*}} = "doo"() : () -> f32
%b = "doo"() : ()->f32
// CHECK: "bar"(%0, %1) : (i64, f32) -> ()
// CHECK: "bar"(%{{.*}}, %{{.*}}) : (i64, f32) -> ()
"bar"(%a, %b) : (i64, f32) -> ()
// CHECK: }
}
@ -228,9 +228,9 @@ func @func_ops_in_loop() {
// CHECK-LABEL: func @loops() {
func @loops() {
// CHECK: affine.for %i0 = 1 to 100 step 2 {
// CHECK: affine.for %{{.*}} = 1 to 100 step 2 {
affine.for %i = 1 to 100 step 2 {
// CHECK: affine.for %i1 = 1 to 200 {
// CHECK: affine.for %{{.*}} = 1 to 200 {
affine.for %j = 1 to 200 {
} // CHECK: }
} // CHECK: }
@ -239,14 +239,14 @@ func @loops() {
// CHECK-LABEL: func @complex_loops() {
func @complex_loops() {
affine.for %i1 = 1 to 100 { // CHECK: affine.for %i0 = 1 to 100 {
affine.for %j1 = 1 to 100 { // CHECK: affine.for %i1 = 1 to 100 {
// CHECK: "foo"(%i0, %i1) : (index, index) -> ()
affine.for %i1 = 1 to 100 { // CHECK: affine.for %{{.*}} = 1 to 100 {
affine.for %j1 = 1 to 100 { // CHECK: affine.for %{{.*}} = 1 to 100 {
// CHECK: "foo"(%{{.*}}, %{{.*}}) : (index, index) -> ()
"foo"(%i1, %j1) : (index,index) -> ()
} // CHECK: }
"boo"() : () -> () // CHECK: "boo"() : () -> ()
affine.for %j2 = 1 to 10 { // CHECK: affine.for %i2 = 1 to 10 {
affine.for %k2 = 1 to 10 { // CHECK: affine.for %i3 = 1 to 10 {
affine.for %j2 = 1 to 10 { // CHECK: affine.for %{{.*}} = 1 to 10 {
affine.for %k2 = 1 to 10 { // CHECK: affine.for %{{.*}} = 1 to 10 {
"goo"() : () -> () // CHECK: "goo"() : () -> ()
} // CHECK: }
} // CHECK: }
@ -254,50 +254,50 @@ func @complex_loops() {
return // CHECK: return
} // CHECK: }
// CHECK: func @triang_loop(%arg0: index, %arg1: memref<?x?xi32>) {
// CHECK: func @triang_loop(%{{.*}}: index, %{{.*}}: memref<?x?xi32>) {
func @triang_loop(%arg0: index, %arg1: memref<?x?xi32>) {
%c = constant 0 : i32 // CHECK: %c0_i32 = constant 0 : i32
affine.for %i0 = 1 to %arg0 { // CHECK: affine.for %i0 = 1 to %arg0 {
affine.for %i1 = (d0)[]->(d0)(%i0)[] to %arg0 { // CHECK: affine.for %i1 = #map{{[0-9]+}}(%i0) to %arg0 {
store %c, %arg1[%i0, %i1] : memref<?x?xi32> // CHECK: store %c0_i32, %arg1[%i0, %i1]
%c = constant 0 : i32 // CHECK: %{{.*}} = constant 0 : i32
affine.for %i0 = 1 to %arg0 { // CHECK: affine.for %{{.*}} = 1 to %{{.*}} {
affine.for %i1 = (d0)[]->(d0)(%i0)[] to %arg0 { // CHECK: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to %{{.*}} {
store %c, %arg1[%i0, %i1] : memref<?x?xi32> // CHECK: store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}]
} // CHECK: }
} // CHECK: }
return // CHECK: return
} // CHECK: }
// CHECK: func @minmax_loop(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
// CHECK: func @minmax_loop(%{{.*}}: index, %{{.*}}: index, %{{.*}}: memref<100xf32>) {
func @minmax_loop(%arg0: index, %arg1: index, %arg2: memref<100xf32>) {
// CHECK: affine.for %i0 = max #map{{.*}}()[%arg0] to min #map{{.*}}()[%arg1] {
// CHECK: affine.for %{{.*}} = max #map{{.*}}()[%{{.*}}] to min #map{{.*}}()[%{{.*}}] {
affine.for %i0 = max()[s]->(0,s-1)()[%arg0] to min()[s]->(100,s+1)()[%arg1] {
// CHECK: "foo"(%arg2, %i0) : (memref<100xf32>, index) -> ()
// CHECK: "foo"(%{{.*}}, %{{.*}}) : (memref<100xf32>, index) -> ()
"foo"(%arg2, %i0) : (memref<100xf32>, index) -> ()
} // CHECK: }
return // CHECK: return
} // CHECK: }
// CHECK-LABEL: func @loop_bounds(%arg0: index) {
// CHECK-LABEL: func @loop_bounds(%{{.*}}: index) {
func @loop_bounds(%N : index) {
// CHECK: %0 = "foo"(%arg0) : (index) -> index
// CHECK: %{{.*}} = "foo"(%{{.*}}) : (index) -> index
%s = "foo"(%N) : (index) -> index
// CHECK: affine.for %i0 = %0 to %arg0
// CHECK: affine.for %{{.*}} = %{{.*}} to %{{.*}}
affine.for %i = %s to %N {
// CHECK: affine.for %i1 = #map{{[0-9]+}}(%i0) to 0
// CHECK: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to 0
affine.for %j = (d0)[]->(d0)(%i)[] to 0 step 1 {
// CHECK: %1 = affine.apply #map{{.*}}(%i0, %i1)[%0]
// CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}]
%w1 = affine.apply(d0, d1)[s0] -> (d0+d1) (%i, %j) [%s]
// CHECK: %2 = affine.apply #map{{.*}}(%i0, %i1)[%0]
// CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}]
%w2 = affine.apply(d0, d1)[s0] -> (s0+1) (%i, %j) [%s]
// CHECK: affine.for %i2 = #map{{.*}}(%1, %i0)[%arg0] to #map{{.*}}(%2, %i1)[%0] {
// CHECK: affine.for %{{.*}} = #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] to #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}] {
affine.for %k = #bound_map1 (%w1, %i)[%N] to (i, j)[s] -> (i + j + s) (%w2, %j)[%s] {
// CHECK: "foo"(%i0, %i1, %i2) : (index, index, index) -> ()
// CHECK: "foo"(%{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index) -> ()
"foo"(%i, %j, %k) : (index, index, index)->()
// CHECK: %c30 = constant 30 : index
// CHECK: %{{.*}} = constant 30 : index
%c = constant 30 : index
// CHECK: %3 = affine.apply #map{{.*}}(%arg0, %c30)
// CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})
%u = affine.apply (d0, d1)->(d0+d1) (%N, %c)
// CHECK: affine.for %i3 = max #map{{.*}}(%i0)[%3] to min #map{{.*}}(%i2)[%c30] {
// CHECK: affine.for %{{.*}} = max #map{{.*}}(%{{.*}})[%{{.*}}] to min #map{{.*}}(%{{.*}})[%{{.*}}] {
affine.for %l = max #bound_map2(%i)[%u] to min #bound_map2(%k)[%c] {
// CHECK: "bar"(%i3) : (index) -> ()
// CHECK: "bar"(%{{.*}}) : (index) -> ()
"bar"(%l) : (index) -> ()
} // CHECK: }
} // CHECK: }
@ -306,20 +306,20 @@ func @loop_bounds(%N : index) {
return // CHECK: return
} // CHECK: }
// CHECK-LABEL: func @ifinst(%arg0: index) {
// CHECK-LABEL: func @ifinst(%{{.*}}: index) {
func @ifinst(%N: index) {
%c = constant 200 : index // CHECK %c200 = constant 200
affine.for %i = 1 to 10 { // CHECK affine.for %i0 = 1 to 10 {
affine.if #set0(%i)[%N, %c] { // CHECK affine.if #set0(%i0)[%arg0, %c200] {
%c = constant 200 : index // CHECK %{{.*}} = constant 200
affine.for %i = 1 to 10 { // CHECK affine.for %{{.*}} = 1 to 10 {
affine.if #set0(%i)[%N, %c] { // CHECK affine.if #set0(%{{.*}})[%{{.*}}, %{{.*}}] {
%x = constant 1 : i32
// CHECK: %c1_i32 = constant 1 : i32
%y = "add"(%x, %i) : (i32, index) -> i32 // CHECK: %0 = "add"(%c1_i32, %i0) : (i32, index) -> i32
%z = "mul"(%y, %y) : (i32, i32) -> i32 // CHECK: %1 = "mul"(%0, %0) : (i32, i32) -> i32
// CHECK: %{{.*}} = constant 1 : i32
%y = "add"(%x, %i) : (i32, index) -> i32 // CHECK: %{{.*}} = "add"(%{{.*}}, %{{.*}}) : (i32, index) -> i32
%z = "mul"(%y, %y) : (i32, i32) -> i32 // CHECK: %{{.*}} = "mul"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
} else { // CHECK } else {
affine.if (i)[N] : (i - 2 >= 0, 4 - i >= 0)(%i)[%N] { // CHECK affine.if (#set1(%i0)[%arg0]) {
// CHECK: %c1 = constant 1 : index
affine.if (i)[N] : (i - 2 >= 0, 4 - i >= 0)(%i)[%N] { // CHECK affine.if (#set1(%{{.*}})[%{{.*}}]) {
// CHECK: %{{.*}} = constant 1 : index
%u = constant 1 : index
// CHECK: %2 = affine.apply #map{{.*}}(%i0, %i0)[%c1]
// CHECK: %{{.*}} = affine.apply #map{{.*}}(%{{.*}}, %{{.*}})[%{{.*}}]
%w = affine.apply (d0,d1)[s0] -> (d0+d1+s0) (%i, %i) [%u]
} else { // CHECK } else {
%v = constant 3 : i32 // %c3_i32 = constant 3 : i32
@ -329,15 +329,15 @@ func @ifinst(%N: index) {
return // CHECK return
} // CHECK }
// CHECK-LABEL: func @simple_ifinst(%arg0: index) {
// CHECK-LABEL: func @simple_ifinst(%{{.*}}: index) {
func @simple_ifinst(%N: index) {
%c = constant 200 : index // CHECK %c200 = constant 200
affine.for %i = 1 to 10 { // CHECK affine.for %i0 = 1 to 10 {
affine.if #set0(%i)[%N, %c] { // CHECK affine.if #set0(%i0)[%arg0, %c200] {
%c = constant 200 : index // CHECK %{{.*}} = constant 200
affine.for %i = 1 to 10 { // CHECK affine.for %{{.*}} = 1 to 10 {
affine.if #set0(%i)[%N, %c] { // CHECK affine.if #set0(%{{.*}})[%{{.*}}, %{{.*}}] {
%x = constant 1 : i32
// CHECK: %c1_i32 = constant 1 : i32
%y = "add"(%x, %i) : (i32, index) -> i32 // CHECK: %0 = "add"(%c1_i32, %i0) : (i32, index) -> i32
%z = "mul"(%y, %y) : (i32, i32) -> i32 // CHECK: %1 = "mul"(%0, %0) : (i32, i32) -> i32
// CHECK: %{{.*}} = constant 1 : i32
%y = "add"(%x, %i) : (i32, index) -> i32 // CHECK: %{{.*}} = "add"(%{{.*}}, %{{.*}}) : (i32, index) -> i32
%z = "mul"(%y, %y) : (i32, i32) -> i32 // CHECK: %{{.*}} = "mul"(%{{.*}}, %{{.*}}) : (i32, i32) -> i32
} // CHECK }
} // CHECK }
return // CHECK return
@ -389,31 +389,31 @@ func @attributes() {
// CHECK-LABEL: func @ssa_values() -> (i16, i8) {
func @ssa_values() -> (i16, i8) {
// CHECK: %0:2 = "foo"() : () -> (i1, i17)
// CHECK: %{{.*}}:2 = "foo"() : () -> (i1, i17)
%0:2 = "foo"() : () -> (i1, i17)
br ^bb2
^bb1: // CHECK: ^bb1: // pred: ^bb2
// CHECK: %1:2 = "baz"(%2#1, %2#0, %0#1) : (f32, i11, i17) -> (i16, i8)
// CHECK: %{{.*}}:2 = "baz"(%{{.*}}#1, %{{.*}}#0, %{{.*}}#1) : (f32, i11, i17) -> (i16, i8)
%1:2 = "baz"(%2#1, %2#0, %0#1) : (f32, i11, i17) -> (i16, i8)
// CHECK: return %1#0, %1#1 : i16, i8
// CHECK: return %{{.*}}#0, %{{.*}}#1 : i16, i8
return %1#0, %1#1 : i16, i8
^bb2: // CHECK: ^bb2: // pred: ^bb0
// CHECK: %2:2 = "bar"(%0#0, %0#1) : (i1, i17) -> (i11, f32)
// CHECK: %{{.*}}:2 = "bar"(%{{.*}}#0, %{{.*}}#1) : (i1, i17) -> (i11, f32)
%2:2 = "bar"(%0#0, %0#1) : (i1, i17) -> (i11, f32)
br ^bb1
}
// CHECK-LABEL: func @bbargs() -> (i16, i8) {
func @bbargs() -> (i16, i8) {
// CHECK: %0:2 = "foo"() : () -> (i1, i17)
// CHECK: %{{.*}}:2 = "foo"() : () -> (i1, i17)
%0:2 = "foo"() : () -> (i1, i17)
br ^bb1(%0#1, %0#0 : i17, i1)
^bb1(%x: i17, %y: i1): // CHECK: ^bb1(%1: i17, %2: i1):
// CHECK: %3:2 = "baz"(%1, %2, %0#1) : (i17, i1, i17) -> (i16, i8)
^bb1(%x: i17, %y: i1): // CHECK: ^bb1(%{{.*}}: i17, %{{.*}}: i1):
// CHECK: %{{.*}}:2 = "baz"(%{{.*}}, %{{.*}}, %{{.*}}#1) : (i17, i1, i17) -> (i16, i8)
%1:2 = "baz"(%x, %y, %0#1) : (i17, i1, i17) -> (i16, i8)
return %1#0, %1#1 : i16, i8
}
@ -421,20 +421,20 @@ func @bbargs() -> (i16, i8) {
// CHECK-LABEL: func @verbose_terminators() -> (i1, i17)
func @verbose_terminators() -> (i1, i17) {
%0:2 = "foo"() : () -> (i1, i17)
// CHECK: br ^bb1(%0#0, %0#1 : i1, i17)
// CHECK: br ^bb1(%{{.*}}#0, %{{.*}}#1 : i1, i17)
"std.br"()[^bb1(%0#0, %0#1 : i1, i17)] : () -> ()
^bb1(%x : i1, %y : i17):
// CHECK: cond_br %1, ^bb2(%2 : i17), ^bb3(%1, %2 : i1, i17)
// CHECK: cond_br %{{.*}}, ^bb2(%{{.*}} : i17), ^bb3(%{{.*}}, %{{.*}} : i1, i17)
"std.cond_br"(%x)[^bb2(%y : i17), ^bb3(%x, %y : i1, i17)] : (i1) -> ()
^bb2(%a : i17):
%true = constant 1 : i1
// CHECK: return %true, %3 : i1, i17
// CHECK: return %{{.*}}, %{{.*}} : i1, i17
"std.return"(%true, %a) : (i1, i17) -> ()
^bb3(%b : i1, %c : i17):
// CHECK: return %4, %5 : i1, i17
// CHECK: return %{{.*}}, %{{.*}} : i1, i17
"std.return"(%b, %c) : (i1, i17) -> ()
}
@ -443,7 +443,7 @@ func @condbr_simple() -> (i32) {
%cond = "foo"() : () -> i1
%a = "bar"() : () -> i32
%b = "bar"() : () -> i64
// CHECK: cond_br %0, ^bb1(%1 : i32), ^bb2(%2 : i64)
// CHECK: cond_br %{{.*}}, ^bb1(%{{.*}} : i32), ^bb2(%{{.*}} : i64)
cond_br %cond, ^bb1(%a : i32), ^bb2(%b : i64)
// CHECK: ^bb1({{.*}}: i32): // pred: ^bb0
@ -461,7 +461,7 @@ func @condbr_moarargs() -> (i32) {
%cond = "foo"() : () -> i1
%a = "bar"() : () -> i32
%b = "bar"() : () -> i64
// CHECK: cond_br %0, ^bb1(%1, %2 : i32, i64), ^bb2(%2, %1, %1 : i64, i32, i32)
// CHECK: cond_br %{{.*}}, ^bb1(%{{.*}}, %{{.*}} : i32, i64), ^bb2(%{{.*}}, %{{.*}}, %{{.*}} : i64, i32, i32)
cond_br %cond, ^bb1(%a, %b : i32, i64), ^bb2(%b, %a, %a : i64, i32, i32)
^bb1(%x : i32, %y : i64):
@ -476,26 +476,26 @@ func @condbr_moarargs() -> (i32) {
// Test pretty printing of constant names.
// CHECK-LABEL: func @constants
func @constants() -> (i32, i23, i23, i1, i1) {
// CHECK: %c42_i32 = constant 42 : i32
// CHECK: %{{.*}} = constant 42 : i32
%x = constant 42 : i32
// CHECK: %c17_i23 = constant 17 : i23
// CHECK: %{{.*}} = constant 17 : i23
%y = constant 17 : i23
// This is a redundant definition of 17, the asmprinter gives it a unique name
// CHECK: %c17_i23_0 = constant 17 : i23
// CHECK: %{{.*}} = constant 17 : i23
%z = constant 17 : i23
// CHECK: %true = constant 1 : i1
// CHECK: %{{.*}} = constant 1 : i1
%t = constant 1 : i1
// CHECK: %false = constant 0 : i1
// CHECK: %{{.*}} = constant 0 : i1
%f = constant 0 : i1
// The trick to parse type declarations should not interfere with hex
// literals.
// CHECK: %c3890_i32 = constant 3890 : i32
// CHECK: %{{.*}} = constant 3890 : i32
%h = constant 0xf32 : i32
// CHECK: return %c42_i32, %c17_i23, %c17_i23_0, %true, %false
// CHECK: return %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}
return %x, %y, %z, %t, %f : i32, i23, i23, i1, i1
}
@ -569,17 +569,17 @@ func @funcattrwithblock() -> ()
#map_non_simple3 = ()[s0] -> (s0 + 3)
func @funcsimplemap(%arg0: index, %arg1: index) -> () {
affine.for %i0 = 0 to #map_simple0()[] {
// CHECK: affine.for %i0 = 0 to 10 {
// CHECK: affine.for %{{.*}} = 0 to 10 {
affine.for %i1 = 0 to #map_simple1()[%arg1] {
// CHECK: affine.for %i1 = 0 to %arg1 {
// CHECK: affine.for %{{.*}} = 0 to %{{.*}} {
affine.for %i2 = 0 to #map_non_simple0(%i0)[] {
// CHECK: affine.for %i2 = 0 to #map{{[a-z_0-9]*}}(%i0) {
// CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}(%{{.*}}) {
affine.for %i3 = 0 to #map_non_simple1(%i0)[%arg1] {
// CHECK: affine.for %i3 = 0 to #map{{[a-z_0-9]*}}(%i0)[%arg1] {
// CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}(%{{.*}})[%{{.*}}] {
affine.for %i4 = 0 to #map_non_simple2()[%arg1, %arg0] {
// CHECK: affine.for %i4 = 0 to #map{{[a-z_0-9]*}}()[%arg1, %arg0] {
// CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}()[%{{.*}}, %{{.*}}] {
affine.for %i5 = 0 to #map_non_simple3()[%arg0] {
// CHECK: affine.for %i5 = 0 to #map{{[a-z_0-9]*}}()[%arg0] {
// CHECK: affine.for %{{.*}} = 0 to #map{{[a-z_0-9]*}}()[%{{.*}}] {
%c42_i32 = constant 42 : i32
}
}
@ -794,7 +794,7 @@ func @no_integer_set_constraints() {
func @verbose_if(%N: index) {
%c = constant 200 : index
// CHECK: affine.if #set{{.*}}(%c200)[%arg0, %c200] {
// CHECK: affine.if #set{{.*}}(%{{.*}})[%{{.*}}, %{{.*}}] {
"affine.if"(%c, %N, %c) ({
// CHECK-NEXT: "add"
%y = "add"(%c, %N) : (index, index) -> index
@ -821,7 +821,7 @@ func @terminator_with_regions() {
// CHECK-LABEL: func @unregistered_term
func @unregistered_term(%arg0 : i1) -> i1 {
// CHECK-NEXT: "unregistered_br"()[^bb1(%arg0 : i1)] : () -> ()
// CHECK-NEXT: "unregistered_br"()[^bb1(%{{.*}} : i1)] : () -> ()
"unregistered_br"()[^bb1(%arg0 : i1)] : () -> ()
^bb1(%arg1 : i1):
@ -841,7 +841,7 @@ func @_valid.function$name()
// CHECK-LABEL: func @external_func_arg_attrs(i32, i1 {dialect.attr = 10 : i64}, i32)
func @external_func_arg_attrs(i32, i1 {dialect.attr = 10 : i64}, i32)
// CHECK-LABEL: func @func_arg_attrs(%arg0: i1 {dialect.attr = 10 : i64})
// CHECK-LABEL: func @func_arg_attrs(%{{.*}}: i1 {dialect.attr = 10 : i64})
func @func_arg_attrs(%arg0: i1 {dialect.attr = 10 : i64}) {
return
}
@ -860,7 +860,7 @@ func @tuple_nested(tuple<tuple<tuple<i32>>>)
// CHECK-LABEL: func @pretty_form_multi_result
func @pretty_form_multi_result() -> (i16, i16) {
// CHECK: %0:2 = "foo_div"() : () -> (i16, i16)
// CHECK: %{{.*}}:2 = "foo_div"() : () -> (i16, i16)
%quot, %rem = "foo_div"() : () -> (i16, i16)
return %quot, %rem : i16, i16
}
@ -893,23 +893,23 @@ func @pretty_dialect_attribute() {
// CHECK-LABEL: func @pretty_dialect_type()
func @pretty_dialect_type() {
// CHECK: %0 = "foo.unknown_op"() : () -> !foo.simpletype
// CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.simpletype
%0 = "foo.unknown_op"() : () -> !foo.simpletype
// CHECK: %1 = "foo.unknown_op"() : () -> !foo.complextype<abcd>
// CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.complextype<abcd>
%1 = "foo.unknown_op"() : () -> !foo.complextype<abcd>
// CHECK: %2 = "foo.unknown_op"() : () -> !foo.complextype<abcd<f32>>
// CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.complextype<abcd<f32>>
%2 = "foo.unknown_op"() : () -> !foo.complextype<abcd<f32>>
// CHECK: %3 = "foo.unknown_op"() : () -> !foo.complextype<abcd<[f]$$[32]>>
// CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.complextype<abcd<[f]$$[32]>>
%3 = "foo.unknown_op"() : () -> !foo.complextype<abcd<[f]$$[32]>>
// CHECK: %4 = "foo.unknown_op"() : () -> !foo.dialect<!x@#!@#>
// CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo.dialect<!x@#!@#>
%4 = "foo.unknown_op"() : () -> !foo.dialect<!x@#!@#>
// Extraneous extra > character can't use the pretty syntax.
// CHECK: %5 = "foo.unknown_op"() : () -> !foo<"dialect<!x@#!@#>>">
// CHECK: %{{.*}} = "foo.unknown_op"() : () -> !foo<"dialect<!x@#!@#>>">
%5 = "foo.unknown_op"() : () -> !foo<"dialect<!x@#!@#>>">
return

78
mlir/test/Linalg/fusion.mlir
View File

@ -28,16 +28,16 @@ func @f2(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<
// FUSE-0-NOT: linalg.for
//
// FUSE-2-LABEL: func @f2
// FUSE-2: %[[C_0:.*]] = linalg.dim %arg2, 0 : !linalg.view<?x?xf32>
// FUSE-2: linalg.for %i0 = %c0 to %[[C_0]] step %c2 {
// FUSE-2: %[[C_0:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// FUSE-2: linalg.for %{{.*}} = %{{.*}} to %[[C_0]] step %{{.*}} {
// FUSE-2: linalg.matmul
// FUSE-2: linalg.matmul
//
// FUSE-23-LABEL: func @f2
// FUSE-23: %[[C_0:.*]] = linalg.dim %arg2, 0 : !linalg.view<?x?xf32>
// FUSE-23: %[[D_1:.*]] = linalg.dim %arg3, 1 : !linalg.view<?x?xf32>
// FUSE-23: linalg.for %i0 = %c0 to %[[C_0]] step %c2 {
// FUSE-23: linalg.for %i1 = %c0 to %[[D_1]] step %c3 {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[C_0]] step %{{.*}} {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[D_1]] step %{{.*}} {
// FUSE-23: linalg.matmul
// FUSE-23: linalg.matmul
//
@ -45,9 +45,9 @@ func @f2(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<
// FUSE-234: %[[C_0:.*]] = linalg.dim %arg2, 0 : !linalg.view<?x?xf32>
// FUSE-234: %[[C_1:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?xf32>
// FUSE-234: %[[D_1:.*]] = linalg.dim %arg3, 1 : !linalg.view<?x?xf32>
// FUSE-234: linalg.for %i0 = %c0 to %[[C_0]] step %c2 {
// FUSE-234: linalg.for %i1 = %c0 to %[[D_1]] step %c3 {
// FUSE-234: linalg.for %i2 = %c0 to %[[C_1]] step %c4 {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[C_0]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[D_1]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[C_1]] step %{{.*}} {
// FUSE-234: linalg.matmul
// FUSE-234: linalg.matmul
@ -67,8 +67,8 @@ func @f3(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<
// FUSE-23-LABEL: func @f3
// FUSE-23: %[[D_0:.*]] = linalg.dim %arg3, 0 : !linalg.view<?x?xf32>
// FUSE-23: %[[C_1:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?xf32>
// FUSE-23: linalg.for %i0 = %c0 to %[[D_0]] step %c2 {
// FUSE-23: linalg.for %i1 = %c0 to %[[C_1]] step %c3 {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[D_0]] step %{{.*}} {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[C_1]] step %{{.*}} {
// FUSE-23: linalg.matmul
// FUSE-23: linalg.matmul
//
@ -76,9 +76,9 @@ func @f3(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<
// FUSE-234: %[[D_0:.*]] = linalg.dim %arg3, 0 : !linalg.view<?x?xf32>
// FUSE-234: %[[D_1:.*]] = linalg.dim %arg3, 1 : !linalg.view<?x?xf32>
// FUSE-234: %[[C_1:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?xf32>
// FUSE-234: linalg.for %i0 = %c0 to %[[D_0]] step %c2 {
// FUSE-234: linalg.for %i1 = %c0 to %[[C_1]] step %c3 {
// FUSE-234: linalg.for %i2 = %c0 to %[[D_1]] step %c4 {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[D_0]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[C_1]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[D_1]] step %{{.*}} {
// FUSE-234: linalg.matmul
// FUSE-234: linalg.matmul
@ -94,17 +94,17 @@ func @f4(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<
//
// Read to %D does not get tiled along 1st dimension => no fusion
// FUSE-2-LABEL: func @f4
// FUSE-2: linalg.matmul(%arg0, %arg1, %arg3)
// FUSE-2: %[[C_0:.*]] = linalg.dim %arg2, 0 : !linalg.view<?x?xf32>
// FUSE-2: linalg.for %i0 = %c0 to %[[C_0]] step %c2 {
// FUSE-2: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}})
// FUSE-2: %[[C_0:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// FUSE-2: linalg.for %{{.*}} = %{{.*}} to %[[C_0]] step %{{.*}} {
// FUSE-2: linalg.matmul
// FUSE-2: linalg.matmul
//
// FUSE-23-LABEL: func @f4
// FUSE-23: %[[C_0:.*]] = linalg.dim %arg2, 0 : !linalg.view<?x?xf32>
// FUSE-23: %[[D_1:.*]] = linalg.dim %arg3, 1 : !linalg.view<?x?xf32>
// FUSE-23: linalg.for %i0 = %c0 to %[[C_0]] step %c2 {
// FUSE-23: linalg.for %i1 = %c0 to %[[D_1]] step %c3 {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[C_0]] step %{{.*}} {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[D_1]] step %{{.*}} {
// FUSE-23: linalg.matmul
// FUSE-23: linalg.matmul
// FUSE-23: linalg.matmul
@ -113,9 +113,9 @@ func @f4(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<
// FUSE-234: %[[C_0:.*]] = linalg.dim %arg2, 0 : !linalg.view<?x?xf32>
// FUSE-234: %[[C_1:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?xf32>
// FUSE-234: %[[D_1:.*]] = linalg.dim %arg3, 1 : !linalg.view<?x?xf32>
// FUSE-234: linalg.for %i0 = %c0 to %[[C_0]] step %c2 {
// FUSE-234: linalg.for %i1 = %c0 to %[[D_1]] step %c3 {
// FUSE-234: linalg.for %i2 = %c0 to %[[C_1]] step %c4 {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[C_0]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[D_1]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[C_1]] step %{{.*}} {
// FUSE-234: linalg.matmul
// FUSE-234: linalg.matmul
// FUSE-234: linalg.matmul
@ -131,29 +131,29 @@ func @f5(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<
// FUSE-0-NOT: linalg.for
//
// FUSE-2-LABEL: func @f5
// FUSE-2: linalg.matmul(%arg0, %arg1, %arg2)
// FUSE-2: %[[D_0:.*]] = linalg.dim %arg3, 0 : !linalg.view<?x?xf32>
// FUSE-2: linalg.for %i0 = %c0 to %[[D_0]] step %c2 {
// FUSE-2: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}})
// FUSE-2: %[[D_0:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// FUSE-2: linalg.for %{{.*}} = %{{.*}} to %[[D_0]] step %{{.*}} {
// FUSE-2: linalg.matmul
// FUSE-2: linalg.matmul
//
// FUSE-23-LABEL: func @f5
// FUSE-23: linalg.matmul(%arg0, %arg1, %arg2)
// FUSE-23: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}})
// FUSE-23: %[[D_0:.*]] = linalg.dim %arg3, 0 : !linalg.view<?x?xf32>
// FUSE-23: %[[B_1:.*]] = linalg.dim %arg1, 1 : !linalg.view<?x?xf32>
// FUSE-23: linalg.for %i0 = %c0 to %[[D_0]] step %c2 {
// FUSE-23: linalg.for %i1 = %c0 to %[[B_1]] step %c3 {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[D_0]] step %{{.*}} {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[B_1]] step %{{.*}} {
// FUSE-23: linalg.matmul
// FUSE-23: linalg.matmul
//
// FUSE-234-LABEL: func @f5
// FUSE-234: linalg.matmul(%arg0, %arg1, %arg2)
// FUSE-234: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}})
// FUSE-234: %[[D_0:.*]] = linalg.dim %arg3, 0 : !linalg.view<?x?xf32>
// FUSE-234: %[[D_1:.*]] = linalg.dim %arg3, 1 : !linalg.view<?x?xf32>
// FUSE-234: %[[B_1:.*]] = linalg.dim %arg1, 1 : !linalg.view<?x?xf32>
// FUSE-234: linalg.for %i0 = %c0 to %[[D_0]] step %c2 {
// FUSE-234: linalg.for %i1 = %c0 to %[[B_1]] step %c3 {
// FUSE-234: linalg.for %i2 = %c0 to %[[D_1]] step %c4 {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[D_0]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[B_1]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[D_1]] step %{{.*}} {
// FUSE-234: linalg.matmul
// FUSE-234: linalg.matmul
@ -196,26 +196,26 @@ func @f7(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<
// FUSE-2-NOT: linalg.for
//
// FUSE-23-LABEL: func @f7
// FUSE-23: linalg.matmul(%arg0, %arg2, %arg4)
// FUSE-23: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}})
// FUSE-23: %[[A_0:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?xf32>
// FUSE-23: %[[C_1:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?xf32>
// FUSE-23: linalg.for %i0 = %c0 to %[[A_0]] step %c2 {
// FUSE-23: linalg.for %i1 = %c0 to %[[C_1]] step %c3 {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[A_0]] step %{{.*}} {
// FUSE-23: linalg.for %{{.*}} = %{{.*}} to %[[C_1]] step %{{.*}} {
// FUSE-23: linalg.matmul
// FUSE-23: linalg.matmul
// FUSE-23: linalg.matmul(%arg2, %arg3, %arg4)
// FUSE-23: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}})
//
// FUSE-234-LABEL: func @f7
// FUSE-234: linalg.matmul(%arg0, %arg2, %arg4)
// FUSE-234: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}})
// FUSE-234: %[[A_0:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?xf32>
// FUSE-234: %[[A_1:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
// FUSE-234: %[[C_1:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?xf32>
// FUSE-234: linalg.for %i0 = %c0 to %[[A_0]] step %c2 {
// FUSE-234: linalg.for %i1 = %c0 to %[[C_1]] step %c3 {
// FUSE-234: linalg.for %i2 = %c0 to %[[A_1]] step %c4 {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[A_0]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[C_1]] step %{{.*}} {
// FUSE-234: linalg.for %{{.*}} = %{{.*}} to %[[A_1]] step %{{.*}} {
// FUSE-234: linalg.matmul
// FUSE-234: linalg.matmul
// FUSE-234: linalg.matmul(%arg2, %arg3, %arg4)
// FUSE-234: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}})
func @f8(%A: !linalg.view<?x?xf32>, %B: !linalg.view<?x?xf32>, %C: !linalg.view<?x?xf32>, %D: !linalg.view<?x?xf32>, %E: !linalg.view<?x?xf32>) -> !linalg.view<?x?xf32> {
linalg.matmul(%A, %C, %D) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>

233
mlir/test/Linalg/llvm.mlir
View File

@ -4,8 +4,8 @@ func @buffer_size(%arg0: !linalg.buffer<?xf32>) {
%s = linalg.buffer_size %arg0 : !linalg.buffer<?xf32>
return
}
// CHECK-LABEL: func @buffer_size(%arg0: !llvm<"{ float*, i64 }">) {
// CHECK: %0 = llvm.extractvalue %arg0[1] : !llvm<"{ float*, i64 }">
// CHECK-LABEL: func @buffer_size(%{{.*}}: !llvm<"{ float*, i64 }">) {
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[1] : !llvm<"{ float*, i64 }">
func @range(%arg0: index) {
%c0 = constant 0 : index
@ -13,106 +13,107 @@ func @range(%arg0: index) {
%R = linalg.range %c0:%arg0:%c1 : !linalg.range
return
}
// CHECK-LABEL: func @range(%arg0: !llvm.i64) {
// CHECK: %0 = llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: %1 = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %2 = llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %3 = llvm.insertvalue %0, %2[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %4 = llvm.insertvalue %arg0, %3[1] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %5 = llvm.insertvalue %1, %4[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-LABEL: func @range(%{{.*}}: !llvm.i64) {
// CHECK: %{{.*}} = llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
func @view(%arg0: !linalg.buffer<?xf32>, %arg1: !linalg.range) {
%0 = linalg.view %arg0[%arg1] : !linalg.buffer<?xf32> -> !linalg.view<?xf32>
return
}
// CHECK-LABEL: func @view(%arg0: !llvm<"{ float*, i64 }">, %arg1: !llvm<"{ i64, i64, i64 }">) {
// CHECK: %0 = llvm.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %1 = llvm.extractvalue %arg0[0] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %2 = llvm.insertvalue %1, %0[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %3 = llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: %4 = llvm.insertvalue %3, %2[1] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %5 = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %6 = llvm.extractvalue %arg1[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %7 = llvm.mul %5, %6 : !llvm.i64
// CHECK-NEXT: %8 = llvm.insertvalue %7, %4[3, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %9 = llvm.extractvalue %arg1[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %10 = llvm.extractvalue %arg1[1] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %11 = llvm.sub %10, %9 : !llvm.i64
// CHECK-NEXT: %12 = llvm.insertvalue %11, %8[2, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-LABEL: func @view(%{{.*}}: !llvm<"{ float*, i64 }">, %{{.*}}: !llvm<"{ i64, i64, i64 }">) {
// CHECK: %{{.*}} = llvm.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[0] : !llvm<"{ float*, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.constant(0 : index) : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.sub %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[2, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
func @view3d(%arg0: !linalg.buffer<?xf32>, %arg1: !linalg.range, %arg2: !linalg.range, %arg3: !linalg.range) {
%0 = linalg.view %arg0[%arg1, %arg2, %arg3] : !linalg.buffer<?xf32> -> !linalg.view<?x?x?xf32>
return
}
// CHECK-LABEL: func @view3d(%arg0: !llvm<"{ float*, i64 }">, %arg1: !llvm<"{ i64, i64, i64 }">, %arg2: !llvm<"{ i64, i64, i64 }">, %arg3: !llvm<"{ i64, i64, i64 }">) {
// CHECK: %5 = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %6 = llvm.extractvalue %arg3[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %7 = llvm.mul %5, %6 : !llvm.i64
// CHECK-NEXT: %8 = llvm.insertvalue %7, %4[3, 2] : !llvm<"{ float*, i64, [3 x i64], [3 x i64] }">
// CHECK: %10 = llvm.extractvalue %arg3[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %13 = llvm.mul %5, %10 : !llvm.i64
// CHECK-NEXT: %14 = llvm.extractvalue %arg2[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %15 = llvm.mul %13, %14 : !llvm.i64
// CHECK-NEXT: %16 = llvm.insertvalue %15, %12[3, 1] : !llvm<"{ float*, i64, [3 x i64], [3 x i64] }">
// CHECK-LABEL: func @view3d(%{{.*}}: !llvm<"{ float*, i64 }">, %{{.*}}: !llvm<"{ i64, i64, i64 }">, %{{.*}}: !llvm<"{ i64, i64, i64 }">, %{{.*}}: !llvm<"{ i64, i64, i64 }">) {
// CHECK: %{{.*}} = llvm.constant(1 : index) : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[3, 2] : !llvm<"{ float*, i64, [3 x i64], [3 x i64] }">
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm<"{ float*, i64, [3 x i64], [3 x i64] }">
func @slice(%arg0: !linalg.buffer<?xf32>, %arg1: !linalg.range) {
%0 = linalg.view %arg0[%arg1] : !linalg.buffer<?xf32> -> !linalg.view<?xf32>
%1 = linalg.slice %0[%arg1] : !linalg.view<?xf32>, !linalg.range, !linalg.view<?xf32>
return
}
// CHECK-LABEL: func @slice(%arg0: !llvm<"{ float*, i64 }">, %arg1: !llvm<"{ i64, i64, i64 }">) {
// CHECK: %13 = llvm.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %14 = llvm.extractvalue %12[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %15 = llvm.insertvalue %14, %13[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %16 = llvm.extractvalue %12[3, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %17 = llvm.extractvalue %12[1] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %18 = llvm.extractvalue %arg1[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %19 = llvm.mul %18, %16 : !llvm.i64
// CHECK-NEXT: %20 = llvm.add %17, %19 : !llvm.i64
// CHECK-NEXT: %21 = llvm.insertvalue %20, %15[1] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %22 = llvm.extractvalue %arg1[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %23 = llvm.extractvalue %arg1[1] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %24 = llvm.sub %23, %22 : !llvm.i64
// CHECK-NEXT: %25 = llvm.insertvalue %24, %21[2, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %26 = llvm.extractvalue %arg1[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %27 = llvm.mul %16, %26 : !llvm.i64
// CHECK-NEXT: %28 = llvm.insertvalue %27, %25[3, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-LABEL: func @slice(%{{.*}}: !llvm<"{ float*, i64 }">, %{{.*}}: !llvm<"{ i64, i64, i64 }">) {
// CHECK: %{{.*}} = llvm.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK: %{{.*}} = llvm.undef : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: llvm.extractvalue %{{.*}}[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[3, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[1] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.add %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.sub %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[2, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
// CHECK-NEXT: %{{.*}} = llvm.extractvalue %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-NEXT: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK-NEXT: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">
func @dot(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<f32>) {
linalg.dot(%arg0, %arg1, %arg2) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
return
}
// CHECK-LABEL: func @dot(%arg0: !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">, %arg1: !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">, %arg2: !llvm<"{ float*, i64, [0 x i64], [0 x i64] }">) {
// CHECK: llvm.call @linalg_dot(%arg0, %arg1, %arg2) : (!llvm<"{ float*, i64, [1 x i64], [1 x i64] }">, !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">, !llvm<"{ float*, i64, [0 x i64], [0 x i64] }">) -> ()
// CHECK-LABEL: func @dot(%{{.*}}: !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">, %{{.*}}: !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">, %{{.*}}: !llvm<"{ float*, i64, [0 x i64], [0 x i64] }">) {
// CHECK: llvm.call @linalg_dot(%{{.*}}, %{{.*}}, %{{.*}}) : (!llvm<"{ float*, i64, [1 x i64], [1 x i64] }">, !llvm<"{ float*, i64, [1 x i64], [1 x i64] }">, !llvm<"{ float*, i64, [0 x i64], [0 x i64] }">) -> ()
func @dim(%arg0: !linalg.view<?x?xf32>) {
%0 = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
return
}
// CHECK-LABEL: func @dim(%arg0: !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">) {
// CHECK: %0 = llvm.extractvalue %arg0[2, 1] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// CHECK-LABEL: func @dim(%{{.*}}: !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">) {
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[2, 1] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
func @range_intersect(%arg0: !linalg.range, %arg1: !linalg.range) -> !linalg.range {
%0 = linalg.range_intersect %arg0, %arg1 : !linalg.range
return %0 : !linalg.range
}
// CHECK-LABEL: func @range_intersect(%arg0: !llvm<"{ i64, i64, i64 }">, %arg1: !llvm<"{ i64, i64, i64 }">) -> !llvm<"{ i64, i64, i64 }"> {
// CHECK: %0 = llvm.extractvalue %arg0[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %1 = llvm.extractvalue %arg1[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %2 = llvm.extractvalue %arg0[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %3 = llvm.extractvalue %arg1[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %4 = llvm.extractvalue %arg0[2] : !llvm<"{ i64, i64, i64 }">
// CHECK: %5 = llvm.extractvalue %arg1[2] : !llvm<"{ i64, i64, i64 }">
// CHECK: %6 = llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: %7 = llvm.icmp "sge" %0, %1 : !llvm.i64
// CHECK: %8 = llvm.select %7, %0, %1 : !llvm.i1, !llvm.i64
// CHECK: %9 = llvm.insertvalue %8, %6[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %10 = llvm.icmp "sle" %2, %3 : !llvm.i64
// CHECK: %11 = llvm.select %10, %2, %3 : !llvm.i1, !llvm.i64
// CHECK: %12 = llvm.insertvalue %11, %9[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %13 = llvm.mul %4, %5 : !llvm.i64
// CHECK: %14 = llvm.insertvalue %13, %12[2] : !llvm<"{ i64, i64, i64 }">
// CHECK: llvm.return %14 : !llvm<"{ i64, i64, i64 }">
// CHECK-LABEL: func @range_intersect(%{{.*}}: !llvm<"{ i64, i64, i64 }">, %{{.*}}: !llvm<"{ i64, i64, i64 }">) -> !llvm<"{ i64, i64, i64 }"> {
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.icmp "sge" %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.i64
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.icmp "sle" %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.i64
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK: llvm.return %{{.*}} : !llvm<"{ i64, i64, i64 }">
func @linalg_for(%arg0 : index, %arg1 : index, %arg2 : index) {
linalg.for %i0 = %arg0 to %arg1 step %arg2 {
@ -120,17 +121,17 @@ func @linalg_for(%arg0 : index, %arg1 : index, %arg2 : index) {
}
return
}
// CHECK-LABEL: func @linalg_for(%arg0: !llvm.i64, %arg1: !llvm.i64, %arg2: !llvm.i64) {
// CHECK: llvm.br ^bb2(%arg0 : !llvm.i64)
// CHECK-LABEL: func @linalg_for(%{{.*}}: !llvm.i64, %{{.*}}: !llvm.i64, %{{.*}}: !llvm.i64) {
// CHECK: llvm.br ^bb2(%{{.*}} : !llvm.i64)
// CHECK: ^bb1: // pred: ^bb2
// CHECK: llvm.return
// CHECK: ^bb2(%0: !llvm.i64): // 2 preds: ^bb0, ^bb3
// CHECK: %1 = llvm.icmp "sgt" %arg1, %0 : !llvm.i64
// CHECK: llvm.cond_br %1, ^bb3, ^bb1
// CHECK: ^bb2(%{{.*}}: !llvm.i64): // 2 preds: ^bb0, ^bb3
// CHECK: %{{.*}} = llvm.icmp "sgt" %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: llvm.cond_br %{{.*}}, ^bb3, ^bb1
// CHECK: ^bb3: // pred: ^bb2
// CHECK: %2 = llvm.mul %0, %arg0 : !llvm.i64
// CHECK: %3 = llvm.add %0, %arg2 : !llvm.i64
// CHECK: llvm.br ^bb2(%3 : !llvm.i64)
// CHECK: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: %{{.*}} = llvm.add %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: llvm.br ^bb2(%{{.*}} : !llvm.i64)
func @linalg_for_2(%arg0 : index, %arg1 : index, %arg2 : index) {
linalg.for %i0 = %arg0 to %arg1 step %arg2 {
@ -143,53 +144,53 @@ func @linalg_for_2(%arg0 : index, %arg1 : index, %arg2 : index) {
}
return
}
// CHECK-LABEL: func @linalg_for_2(%arg0: !llvm.i64, %arg1: !llvm.i64, %arg2: !llvm.i64) {
// CHECK: llvm.br ^bb2(%arg0 : !llvm.i64)
// CHECK-LABEL: func @linalg_for_2(%{{.*}}: !llvm.i64, %{{.*}}: !llvm.i64, %{{.*}}: !llvm.i64) {
// CHECK: llvm.br ^bb2(%{{.*}} : !llvm.i64)
// CHECK: ^bb1: // pred: ^bb2
// CHECK: llvm.return
// CHECK: ^bb2(%0: !llvm.i64): // 2 preds: ^bb0, ^bb5
// CHECK: %1 = llvm.icmp "sgt" %arg1, %0 : !llvm.i64
// CHECK: llvm.cond_br %1, ^bb3, ^bb1
// CHECK: ^bb2(%{{.*}}: !llvm.i64): // 2 preds: ^bb0, ^bb5
// CHECK: %{{.*}} = llvm.icmp "sgt" %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: llvm.cond_br %{{.*}}, ^bb3, ^bb1
// CHECK: ^bb3: // pred: ^bb2
// CHECK: llvm.br ^bb8(%arg0 : !llvm.i64)
// CHECK: llvm.br ^bb8(%{{.*}} : !llvm.i64)
// CHECK: ^bb4: // pred: ^bb8
// CHECK: llvm.br ^bb6(%arg0 : !llvm.i64)
// CHECK: llvm.br ^bb6(%{{.*}} : !llvm.i64)
// CHECK: ^bb5: // pred: ^bb6
// CHECK: %2 = llvm.add %0, %arg2 : !llvm.i64
// CHECK: llvm.br ^bb2(%2 : !llvm.i64)
// CHECK: ^bb6(%3: !llvm.i64): // 2 preds: ^bb4, ^bb7
// CHECK: %4 = llvm.icmp "sgt" %arg1, %3 : !llvm.i64
// CHECK: llvm.cond_br %4, ^bb7, ^bb5
// CHECK: %{{.*}} = llvm.add %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: llvm.br ^bb2(%{{.*}} : !llvm.i64)
// CHECK: ^bb6(%{{.*}}: !llvm.i64): // 2 preds: ^bb4, ^bb7
// CHECK: %{{.*}} = llvm.icmp "sgt" %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: llvm.cond_br %{{.*}}, ^bb7, ^bb5
// CHECK: ^bb7: // pred: ^bb6
// CHECK: %5 = llvm.mul %0, %3 : !llvm.i64
// CHECK: %6 = llvm.add %3, %arg2 : !llvm.i64
// CHECK: llvm.br ^bb6(%6 : !llvm.i64)
// CHECK: ^bb8(%7: !llvm.i64): // 2 preds: ^bb3, ^bb9
// CHECK: %8 = llvm.icmp "sgt" %arg1, %7 : !llvm.i64
// CHECK: llvm.cond_br %8, ^bb9, ^bb4
// CHECK: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: %{{.*}} = llvm.add %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: llvm.br ^bb6(%{{.*}} : !llvm.i64)
// CHECK: ^bb8(%{{.*}}: !llvm.i64): // 2 preds: ^bb3, ^bb9
// CHECK: %{{.*}} = llvm.icmp "sgt" %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: llvm.cond_br %{{.*}}, ^bb9, ^bb4
// CHECK: ^bb9: // pred: ^bb8
// CHECK: %9 = llvm.mul %0, %7 : !llvm.i64
// CHECK: %10 = llvm.add %7, %arg2 : !llvm.i64
// CHECK: llvm.br ^bb8(%10 : !llvm.i64)
// CHECK: %{{.*}} = llvm.mul %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: %{{.*}} = llvm.add %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: llvm.br ^bb8(%{{.*}} : !llvm.i64)
func @subview(%arg0: !linalg.view<?x?xf32>) {
%c0 = constant 0 : index
%0 = linalg.subview %arg0[%c0, %c0, %c0, %c0, %c0, %c0] : !linalg.view<?x?xf32>
return
}
// CHECK-LABEL: func @subview(%arg0: !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">) {
// CHECK: %0 = llvm.constant(0 : index) : !llvm.i64
// CHECK: %1 = llvm.extractvalue %arg0[2, 0] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// CHECK: %2 = llvm.icmp "slt" %1, %0 : !llvm.i64
// CHECK: %3 = llvm.select %2, %1, %0 : !llvm.i1, !llvm.i64
// CHECK: %4 = llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: %5 = llvm.insertvalue %0, %4[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %6 = llvm.insertvalue %3, %5[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %7 = llvm.insertvalue %0, %6[2] : !llvm<"{ i64, i64, i64 }">
// CHECK: %8 = llvm.extractvalue %arg0[2, 1] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// CHECK: %9 = llvm.icmp "slt" %8, %0 : !llvm.i64
// CHECK: %10 = llvm.select %9, %8, %0 : !llvm.i1, !llvm.i64
// CHECK: %11 = llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: %12 = llvm.insertvalue %0, %11[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %13 = llvm.insertvalue %10, %12[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %14 = llvm.insertvalue %0, %13[2] : !llvm<"{ i64, i64, i64 }">
// CHECK-LABEL: func @subview(%{{.*}}: !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">) {
// CHECK: %{{.*}} = llvm.constant(0 : index) : !llvm.i64
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[2, 0] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// CHECK: %{{.*}} = llvm.icmp "slt" %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.i64
// CHECK: %{{.*}} = llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.extractvalue %{{.*}}[2, 1] : !llvm<"{ float*, i64, [2 x i64], [2 x i64] }">
// CHECK: %{{.*}} = llvm.icmp "slt" %{{.*}}, %{{.*}} : !llvm.i64
// CHECK: %{{.*}} = llvm.select %{{.*}}, %{{.*}}, %{{.*}} : !llvm.i1, !llvm.i64
// CHECK: %{{.*}} = llvm.undef : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"{ i64, i64, i64 }">
// CHECK: %{{.*}} = llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm<"{ i64, i64, i64 }">

146
mlir/test/Linalg/loops.mlir
View File

@ -16,22 +16,22 @@ func @matmul(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: in
linalg.matmul(%A, %B, %C) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
return
}
// CHECK-LABEL: func @matmul(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: index) {
// CHECK-LABEL: func @matmul(%{{.*}}: !linalg.buffer<?xf32>, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK: %[[A:.*]] = linalg.view %arg0[{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?x?xf32>
// CHECK: %[[B:.*]] = linalg.view %arg0[{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?x?xf32>
// CHECK: %[[C:.*]] = linalg.view %arg0[{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?x?xf32>
// CHECK: %[[M:.*]] = linalg.dim %[[A]], 0 : !linalg.view<?x?xf32>
// CHECK: %[[K:.*]] = linalg.dim %[[A]], 1 : !linalg.view<?x?xf32>
// CHECK: %[[N:.*]] = linalg.dim %[[B]], 1 : !linalg.view<?x?xf32>
// CHECK: linalg.for %i0 = %c0 to %[[M]] step %c1 {
// CHECK: linalg.for %i1 = %c0 to %[[N]] step %c1 {
// CHECK: linalg.for %i2 = %c0 to %[[K]] step %c1 {
// CHECK-DAG: %[[a:.*]] = linalg.load %[[A]][%i0, %i2] : !linalg.view<?x?xf32>
// CHECK-DAG: %[[b:.*]] = linalg.load %[[B]][%i2, %i1] : !linalg.view<?x?xf32>
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[M]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[N]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
// CHECK-DAG: %[[a:.*]] = linalg.load %[[A]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK-DAG: %[[b:.*]] = linalg.load %[[B]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK-DAG: %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
// CHECK-DAG: %[[c:.*]] = linalg.load %[[C]][%i0, %i1] : !linalg.view<?x?xf32>
// CHECK-DAG: %[[c:.*]] = linalg.load %[[C]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK-DAG: %[[res:.*]] = addf %[[c]], %[[inc]] : f32
// CHECK: linalg.store %[[res]], %[[C]][%i0, %i1] : !linalg.view<?x?xf32>
// CHECK: linalg.store %[[res]], %[[C]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
func @matvec(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: index) {
%c0 = constant 0 : index
@ -44,20 +44,20 @@ func @matvec(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: in
linalg.matvec(%2, %3, %4) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
return
}
// CHECK-LABEL: func @matvec(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: index) {
// CHECK-LABEL: func @matvec(%{{.*}}: !linalg.buffer<?xf32>, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK: %[[A:.*]] = linalg.view %arg0[{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?x?xf32>
// CHECK: %[[B:.*]] = linalg.view %arg0[{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?xf32>
// CHECK: %[[C:.*]] = linalg.view %arg0[{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?xf32>
// CHECK: %[[M:.*]] = linalg.dim %[[A]], 0 : !linalg.view<?x?xf32>
// CHECK: %[[K:.*]] = linalg.dim %[[A]], 1 : !linalg.view<?x?xf32>
// CHECK: linalg.for %i0 = %c0 to %[[M]] step %c1 {
// CHECK: linalg.for %i1 = %c0 to %[[K]] step %c1 {
// CHECK-DAG: %[[a:.*]] = linalg.load %[[A]][%i0, %i1] : !linalg.view<?x?xf32>
// CHECK-DAG: %[[b:.*]] = linalg.load %[[B]][%i1] : !linalg.view<?xf32>
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[M]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
// CHECK-DAG: %[[a:.*]] = linalg.load %[[A]][%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>
// CHECK-DAG: %[[b:.*]] = linalg.load %[[B]][%{{.*}}] : !linalg.view<?xf32>
// CHECK-DAG: %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
// CHECK-DAG: %[[c:.*]] = linalg.load %[[C]][%i0] : !linalg.view<?xf32>
// CHECK-DAG: %[[c:.*]] = linalg.load %[[C]][%{{.*}}] : !linalg.view<?xf32>
// CHECK-DAG: %[[res:.*]] = addf %[[c]], %[[inc]] : f32
// CHECK: linalg.store %[[res]], %[[C]][%i0] : !linalg.view<?xf32>
// CHECK: linalg.store %[[res]], %[[C]][%{{.*}}] : !linalg.view<?xf32>
func @dot(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: index) {
%c0 = constant 0 : index
@ -69,14 +69,14 @@ func @dot(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: index
linalg.dot(%1, %2, %3) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
return
}
// CHECK-LABEL: func @dot(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: index) {
// CHECK-LABEL: func @dot(%{{.*}}: !linalg.buffer<?xf32>, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK: %[[A:.*]] = linalg.view %arg0[{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?xf32>
// CHECK: %[[B:.*]] = linalg.view %arg0[{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?xf32>
// CHECK: %[[C:.*]] = linalg.view %arg0[] : !linalg.buffer<?xf32> -> !linalg.view<f32>
// CHECK: %[[K:.*]] = linalg.dim %[[A]], 0 : !linalg.view<?xf32>
// CHECK: linalg.for %i0 = %c0 to %[[K]] step %c1 {
// CHECK-DAG: %[[a:.*]] = linalg.load %[[A]][%i0] : !linalg.view<?xf32>
// CHECK-DAG: %[[b:.*]] = linalg.load %[[B]][%i0] : !linalg.view<?xf32>
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
// CHECK-DAG: %[[a:.*]] = linalg.load %[[A]][%{{.*}}] : !linalg.view<?xf32>
// CHECK-DAG: %[[b:.*]] = linalg.load %[[B]][%{{.*}}] : !linalg.view<?xf32>
// CHECK-DAG: %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
// CHECK-DAG: %[[c:.*]] = linalg.load %[[C]][] : !linalg.view<f32>
// CHECK-DAG: %[[res:.*]] = addf %[[c]], %[[inc]] : f32
@ -86,57 +86,57 @@ func @dot_view(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !l
linalg.dot(%arg0, %arg1, %arg2) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
return
}
// CHECK-LABEL: func @dot_view(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<f32>) {
// CHECK-LABEL: func @dot_view(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<f32>) {
// CHECK: %[[K:.*]] = linalg.dim %arg0, 0 : !linalg.view<?xf32>
// CHECK: linalg.for %i0 = %c0 to %[[K]] step %c1 {
// CHECK-DAG: %[[a:.*]] = linalg.load %arg0[%i0] : !linalg.view<?xf32>
// CHECK-DAG: %[[b:.*]] = linalg.load %arg1[%i0] : !linalg.view<?xf32>
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
// CHECK-DAG: %[[a:.*]] = linalg.load %arg0[%{{.*}}] : !linalg.view<?xf32>
// CHECK-DAG: %[[b:.*]] = linalg.load %{{.*}}[%{{.*}}] : !linalg.view<?xf32>
// CHECK-DAG: %[[inc:.*]] = mulf %[[a]], %[[b]] : f32
// CHECK-DAG: %[[c:.*]] = linalg.load %arg2[] : !linalg.view<f32>
// CHECK-DAG: %[[c:.*]] = linalg.load %{{.*}}[] : !linalg.view<f32>
// CHECK-DAG: %[[res:.*]] = addf %[[c]], %[[inc]] : f32
// CHECK: linalg.store %[[res]], %arg2[] : !linalg.view<f32>
// CHECK: linalg.store %[[res]], %{{.*}}[] : !linalg.view<f32>
func @fill_view(%arg0: !linalg.view<?xf32>, %arg1: f32) {
linalg.fill(%arg0, %arg1) : !linalg.view<?xf32>, f32
return
}
// CHECK-LABEL: func @fill_view(%arg0: !linalg.view<?xf32>, %arg1: f32) {
// CHECK: linalg.for %i0 = %c0 to %0 step %c1 {
// CHECK: linalg.store %arg1, %arg0[%i0] : !linalg.view<?xf32>
// CHECK-LABEL: func @fill_view(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: f32) {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK: linalg.store %{{.*}}, %{{.*}}[%{{.*}}] : !linalg.view<?xf32>
func @fill_view0(%arg0: !linalg.view<f32>, %arg1: f32) {
linalg.fill(%arg0, %arg1) : !linalg.view<f32>, f32
return
}
// CHECK-LABEL: func @fill_view0(%arg0: !linalg.view<f32>, %arg1: f32) {
// CHECK: linalg.store %arg1, %arg0[] : !linalg.view<f32>
// CHECK-LABEL: func @fill_view0(%{{.*}}: !linalg.view<f32>, %{{.*}}: f32) {
// CHECK: linalg.store %{{.*}}, %{{.*}}[] : !linalg.view<f32>
func @fill_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: f32) {
linalg.fill(%arg0, %arg1) : !linalg.view<?x?x?xf32>, f32
return
}
// CHECK-LABEL: func @fill_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: f32) {
// CHECK: linalg.for %i0 = %c0 to %{{.*}} step %c1 {
// CHECK: linalg.for %i1 = %c0 to %{{.*}} step %c1 {
// CHECK: linalg.for %i2 = %c0 to %{{.*}} step %c1 {
// CHECK: linalg.store %arg1, %arg0[%i0, %i1, %i2] : !linalg.view<?x?x?xf32>
// CHECK-LABEL: func @fill_view3(%{{.*}}: !linalg.view<?x?x?xf32>, %{{.*}}: f32) {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK: linalg.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?xf32>
func @copy_view(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>) {
linalg.copy(%arg0, %arg1) : !linalg.view<?xf32>, !linalg.view<?xf32>
return
}
// CHECK-LABEL: func @copy_view(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>) {
// CHECK: linalg.for %i0 = %c0 to %0 step %c1 {
// CHECK: %[[L:.*]] = linalg.load %arg0[%i0] : !linalg.view<?xf32>
// CHECK: linalg.store %[[L]], %arg1[%i0] : !linalg.view<?xf32>
// CHECK-LABEL: func @copy_view(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>) {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK: %[[L:.*]] = linalg.load %{{.*}}[%{{.*}}] : !linalg.view<?xf32>
// CHECK: linalg.store %[[L]], %{{.*}}[%{{.*}}] : !linalg.view<?xf32>
func @copy_view0(%arg0: !linalg.view<f32>, %arg1: !linalg.view<f32>) {
linalg.copy(%arg0, %arg1) : !linalg.view<f32>, !linalg.view<f32>
return
}
// CHECK-LABEL: func @copy_view0(%arg0: !linalg.view<f32>, %arg1: !linalg.view<f32>) {
// CHECK: %0 = linalg.load %arg0[] : !linalg.view<f32>
// CHECK: linalg.store %0, %arg1[] : !linalg.view<f32>
// CHECK-LABEL: func @copy_view0(%{{.*}}: !linalg.view<f32>, %{{.*}}: !linalg.view<f32>) {
// CHECK: %{{.*}} = linalg.load %{{.*}}[] : !linalg.view<f32>
// CHECK: linalg.store %{{.*}}, %{{.*}}[] : !linalg.view<f32>
func @copy_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>) {
linalg.copy(%arg0, %arg1) {inputPermutation = (i, j, k) -> (i, k, j),
@ -144,41 +144,41 @@ func @copy_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>)
!linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>
return
}
// CHECK-LABEL: func @copy_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>) {
// CHECK: linalg.for %i0 = %c0 to %{{.*}} step %c1 {
// CHECK: linalg.for %i1 = %c0 to %{{.*}} step %c1 {
// CHECK: linalg.for %i2 = %c0 to %{{.*}} step %c1 {
// CHECK: %[[L:.*]] = linalg.load %arg0[%i0, %i2, %i1] : !linalg.view<?x?x?xf32>
// CHECK: linalg.store %[[L]], %arg1[%i2, %i1, %i0] : !linalg.view<?x?x?xf32>
// CHECK-LABEL: func @copy_view3(%{{.*}}: !linalg.view<?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?xf32>) {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK: %[[L:.*]] = linalg.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?xf32>
// CHECK: linalg.store %[[L]], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?xf32>
func @conv_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>, %arg2: !linalg.view<?x?x?xf32>) {
linalg.conv(%arg0, %arg1, %arg2) {strides = [2]}: !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>
return
}
// CHECK-LABEL: func @conv_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>, %arg2: !linalg.view<?x?x?xf32>) {
// CHECK-LABEL: func @conv_view3(%{{.*}}: !linalg.view<?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?xf32>) {
// CHECK: %[[Z0:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?x?xf32>
// CHECK: %[[Q:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?x?xf32>
// CHECK: %[[K:.*]] = linalg.dim %arg0, 2 : !linalg.view<?x?x?xf32>
// CHECK: %[[B:.*]] = linalg.dim %arg1, 0 : !linalg.view<?x?x?xf32>
// CHECK: %[[X0:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?x?xf32>
// CHECK: linalg.for %i0 = %c0 to %[[B]] step %c1 {
// CHECK: linalg.for %i1 = %c0 to %[[X0]] step %c1 {
// CHECK: linalg.for %i2 = %c0 to %[[K]] step %c1 {
// CHECK: linalg.for %i3 = %c0 to %[[Q]] step %c1 {
// CHECK: linalg.for %i4 = %c0 to %[[Z0]] step %c1 {
// CHECK: %[[SUM:.*]] = affine.apply #[[S2D1]](%i1, %i4)
// CHECK: %{{.*}} = linalg.load %arg1[%i0, %[[SUM]], %i3] : !linalg.view<?x?x?xf32>
// CHECK: %{{.*}} = linalg.load %arg0[%i4, %i3, %i2] : !linalg.view<?x?x?xf32>
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[B]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[X0]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[Q]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[Z0]] step %{{.*}} {
// CHECK: %[[SUM:.*]] = affine.apply #[[S2D1]](%{{.*}}, %{{.*}})
// CHECK: %{{.*}} = linalg.load %{{.*}}[%{{.*}}, %[[SUM]], %{{.*}}] : !linalg.view<?x?x?xf32>
// CHECK: %{{.*}} = linalg.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?xf32>
// CHECK: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
// CHECK: %{{.*}} = linalg.load %arg2[%i0, %i1, %i2] : !linalg.view<?x?x?xf32>
// CHECK: %{{.*}} = linalg.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?xf32>
// CHECK: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK: linalg.store %{{.*}}, %arg2[%i0, %i1, %i2] : !linalg.view<?x?x?xf32>
// CHECK: linalg.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?xf32>
func @conv_view4(%arg0: !linalg.view<?x?x?x?xf32>, %arg1: !linalg.view<?x?x?x?xf32>, %arg2: !linalg.view<?x?x?x?xf32>) {
linalg.conv(%arg0, %arg1, %arg2) {dilations = [4, 5], strides = [2, 3]} : !linalg.view<?x?x?x?xf32>, !linalg.view<?x?x?x?xf32>, !linalg.view<?x?x?x?xf32>
return
}
// CHECK-LABEL: func @conv_view4(%arg0: !linalg.view<?x?x?x?xf32>, %arg1: !linalg.view<?x?x?x?xf32>, %arg2: !linalg.view<?x?x?x?xf32>) {
// CHECK-LABEL: func @conv_view4(%{{.*}}: !linalg.view<?x?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?x?xf32>) {
// CHECK: %[[Z0:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?x?x?xf32>
// CHECK: %[[Z1:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?x?x?xf32>
// CHECK: %[[Q:.*]] = linalg.dim %arg0, 2 : !linalg.view<?x?x?x?xf32>
@ -186,18 +186,18 @@ func @conv_view4(%arg0: !linalg.view<?x?x?x?xf32>, %arg1: !linalg.view<?x?x?x?xf
// CHECK: %[[B:.*]] = linalg.dim %arg1, 0 : !linalg.view<?x?x?x?xf32>
// CHECK: %[[X0:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?x?x?xf32>
// CHECK: %[[X1:.*]] = linalg.dim %arg2, 2 : !linalg.view<?x?x?x?xf32>
// CHECK: linalg.for %i0 = %c0 to %[[B]] step %c1 {
// CHECK: linalg.for %i1 = %c0 to %[[X0]] step %c1 {
// CHECK: linalg.for %i2 = %c0 to %[[X1]] step %c1 {
// CHECK: linalg.for %i3 = %c0 to %[[K]] step %c1 {
// CHECK: linalg.for %i4 = %c0 to %[[Q]] step %c1 {
// CHECK: linalg.for %i5 = %c0 to %[[Z0]] step %c1 {
// CHECK: linalg.for %i6 = %c0 to %[[Z1]] step %c1 {
// CHECK: %[[SUM0:.*]] = affine.apply #map1(%i1, %i5)
// CHECK: %[[SUM1:.*]] = affine.apply #map2(%i2, %i6)
// CHECK: %{{.*}} = linalg.load %arg1[%i0, %[[SUM0]], %[[SUM1]], %i4] : !linalg.view<?x?x?x?xf32>
// CHECK: %{{.*}} = linalg.load %arg0[%i5, %i6, %i4, %i3] : !linalg.view<?x?x?x?xf32>
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[B]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[X0]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[X1]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[K]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[Q]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[Z0]] step %{{.*}} {
// CHECK: linalg.for %{{.*}} = %{{.*}} to %[[Z1]] step %{{.*}} {
// CHECK: %[[SUM0:.*]] = affine.apply #map1(%{{.*}}, %{{.*}})
// CHECK: %[[SUM1:.*]] = affine.apply #map2(%{{.*}}, %{{.*}})
// CHECK: %{{.*}} = linalg.load %{{.*}}[%{{.*}}, %[[SUM0]], %[[SUM1]], %{{.*}}] : !linalg.view<?x?x?x?xf32>
// CHECK: %{{.*}} = linalg.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?x?xf32>
// CHECK: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
// CHECK: %{{.*}} = linalg.load %arg2[%i0, %i1, %i2, %i3] : !linalg.view<?x?x?x?xf32>
// CHECK: %{{.*}} = linalg.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?x?xf32>
// CHECK: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK: linalg.store %{{.*}}, %arg2[%i0, %i1, %i2, %i3] : !linalg.view<?x?x?x?xf32>
// CHECK: linalg.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?x?x?xf32>

8
mlir/test/Linalg/promote.mlir
View File

@ -12,10 +12,10 @@ func @matmul(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: in
linalg.matmul(%A, %B, %C) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
return
}
// TILE-1D-LABEL: func @matmul(%arg0: !linalg.buffer<?xf32>, %arg1: index, %arg2: index, %arg3: index) {
// TILE-1D: linalg.for %i0 = %c0 to %6 step %c2 {
// TILE-1D: linalg.for %i1 = %c0 to %9 step %c3 {
// TILE-1D: linalg.for %i2 = %c0 to %7 step %c4 {
// TILE-1D-LABEL: func @matmul(%{{.*}}: !linalg.buffer<?xf32>, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// TILE-1D: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// TILE-1D: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// TILE-1D: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// TILE-1D: %[[vA:.*]] = linalg.subview {{.*}} : !linalg.view<?x?xf32>
// TILE-1D: %[[vB:.*]] = linalg.subview {{.*}} : !linalg.view<?x?xf32>
// TILE-1D: %[[vC:.*]] = linalg.subview {{.*}} : !linalg.view<?x?xf32>

106
mlir/test/Linalg/roundtrip.mlir
View File

@ -7,8 +7,8 @@ func @range(%arg0: index, %arg1: index, %arg2: index) {
%0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range
return
}
// CHECK-LABEL: func @range(%arg0: index, %arg1: index, %arg2: index) {
// CHECK-NEXT: %0 = linalg.range %arg0:%arg1:%arg2 : !linalg.range
// CHECK-LABEL: func @range(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK-NEXT: %{{.*}} = linalg.range %{{.*}}:%{{.*}}:%{{.*}} : !linalg.range
func @buffer(%arg0: index, %arg1: index) {
%0 = muli %arg0, %arg0 : index
@ -18,17 +18,17 @@ func @buffer(%arg0: index, %arg1: index) {
linalg.buffer_dealloc %1 : !linalg.buffer<?xvector<4xi8>>
return
}
// CHECK-LABEL: func @buffer(%arg0: index, %arg1: index) {
// CHECK-NEXT: %0 = muli %arg0, %arg0 : index
// CHECK-NEXT: %1 = linalg.buffer_alloc %0 : !linalg.buffer<?xvector<4xi8>>
// CHECK-NEXT: %2 = linalg.buffer_alloc : !linalg.buffer<17xvector<4xi8>>
// CHECK-NEXT: linalg.buffer_dealloc %2 : !linalg.buffer<17xvector<4xi8>>
// CHECK-NEXT: linalg.buffer_dealloc %1 : !linalg.buffer<?xvector<4xi8>>
// CHECK-LABEL: func @buffer(%{{.*}}: index, %{{.*}}: index) {
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = linalg.buffer_alloc %{{.*}} : !linalg.buffer<?xvector<4xi8>>
// CHECK-NEXT: %{{.*}} = linalg.buffer_alloc : !linalg.buffer<17xvector<4xi8>>
// CHECK-NEXT: linalg.buffer_dealloc %{{.*}} : !linalg.buffer<17xvector<4xi8>>
// CHECK-NEXT: linalg.buffer_dealloc %{{.*}} : !linalg.buffer<?xvector<4xi8>>
func @view_fun(%arg0: !linalg.view<?x?xvector<3x4xi4>>) {
return
}
// CHECK-LABEL: func @view_fun(%arg0: !linalg.view<?x?xvector<3x4xi4>>) {
// CHECK-LABEL: func @view_fun(%{{.*}}: !linalg.view<?x?xvector<3x4xi4>>) {
func @views(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index) {
%0 = muli %arg0, %arg0 : index
@ -42,16 +42,16 @@ func @views(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index
linalg.buffer_dealloc %1 : !linalg.buffer<?xf32>
return
}
// CHECK-LABEL: func @views(%arg0: index, %arg1: index, %arg2: index, %arg3: index, %arg4: index) {
// CHECK-NEXT: %0 = muli %arg0, %arg0 : index
// CHECK-NEXT: %1 = linalg.buffer_alloc %0 : !linalg.buffer<?xf32>
// CHECK-NEXT: %2 = linalg.range %arg2:%arg3:%arg4 : !linalg.range
// CHECK-NEXT: %3 = linalg.view %1[%2, %2] : !linalg.buffer<?xf32> -> !linalg.view<?x?xf32>
// CHECK-NEXT: %4 = linalg.slice %3[%2, %2] : !linalg.view<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: %5 = linalg.slice %3[%2, %arg2] : !linalg.view<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK-NEXT: %6 = linalg.slice %3[%arg2, %2] : !linalg.view<?x?xf32>, index, !linalg.range, !linalg.view<?xf32>
// CHECK-NEXT: %7 = linalg.slice %3[%arg2, %arg3] : !linalg.view<?x?xf32>, index, index, !linalg.view<f32>
// CHECK-NEXT: linalg.buffer_dealloc %1 : !linalg.buffer<?xf32>
// CHECK-LABEL: func @views(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = linalg.buffer_alloc %{{.*}} : !linalg.buffer<?xf32>
// CHECK-NEXT: %{{.*}} = linalg.range %{{.*}}:%{{.*}}:%{{.*}} : !linalg.range
// CHECK-NEXT: %{{.*}} = linalg.view %{{.*}}[%{{.*}}, %{{.*}}] : !linalg.buffer<?xf32> -> !linalg.view<?x?xf32>
// CHECK-NEXT: %{{.*}} = linalg.slice %{{.*}}[%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>, !linalg.range, !linalg.range, !linalg.view<?x?xf32>
// CHECK-NEXT: %{{.*}} = linalg.slice %{{.*}}[%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>, !linalg.range, index, !linalg.view<?xf32>
// CHECK-NEXT: %{{.*}} = linalg.slice %{{.*}}[%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>, index, !linalg.range, !linalg.view<?xf32>
// CHECK-NEXT: %{{.*}} = linalg.slice %{{.*}}[%{{.*}}, %{{.*}}] : !linalg.view<?x?xf32>, index, index, !linalg.view<f32>
// CHECK-NEXT: linalg.buffer_dealloc %{{.*}} : !linalg.buffer<?xf32>
func @ops(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<?xf32>, %arg3: !linalg.view<f32>) {
linalg.matmul(%arg0, %arg0, %arg0) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
@ -59,10 +59,10 @@ func @ops(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !lina
linalg.dot(%arg1, %arg2, %arg3) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
return
}
// CHECK-LABEL: func @ops(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<?xf32>, %arg3: !linalg.view<f32>) {
// CHECK-NEXT: linalg.matmul(%arg0, %arg0, %arg0) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
// CHECK-NEXT: linalg.matvec(%arg0, %arg1, %arg2) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
// CHECK-NEXT: linalg.dot(%arg1, %arg2, %arg3) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
// CHECK-LABEL: func @ops(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<f32>) {
// CHECK-NEXT: linalg.matmul(%{{.*}}, %{{.*}}, %{{.*}}) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
// CHECK-NEXT: linalg.matvec(%{{.*}}, %{{.*}}, %{{.*}}) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
// CHECK-NEXT: linalg.dot(%{{.*}}, %{{.*}}, %{{.*}}) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
func @dim(%arg0: !linalg.view<?x?xf32>) {
%0 = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
@ -70,18 +70,18 @@ func @dim(%arg0: !linalg.view<?x?xf32>) {
linalg.buffer_dealloc %1 : !linalg.buffer<?xf32>
return
}
// CHECK-LABEL: func @dim(%arg0: !linalg.view<?x?xf32>) {
// CHECK-NEXT: %0 = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
// CHECK-NEXT: %1 = linalg.buffer_alloc %0 : !linalg.buffer<?xf32>
// CHECK-NEXT: linalg.buffer_dealloc %1 : !linalg.buffer<?xf32>
// CHECK-LABEL: func @dim(%{{.*}}: !linalg.view<?x?xf32>) {
// CHECK-NEXT: %{{.*}} = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// CHECK-NEXT: %{{.*}} = linalg.buffer_alloc %{{.*}} : !linalg.buffer<?xf32>
// CHECK-NEXT: linalg.buffer_dealloc %{{.*}} : !linalg.buffer<?xf32>
func @range_intersect(%arg0: !linalg.range, %arg1: !linalg.range) -> !linalg.range {
%0 = linalg.range_intersect %arg0, %arg1 : !linalg.range
return %0 : !linalg.range
}
// CHECK-LABEL: func @range_intersect(%arg0: !linalg.range, %arg1: !linalg.range) -> !linalg.range {
// CHECK-NEXT: %0 = linalg.range_intersect %arg0, %arg1 : !linalg.range
// CHECK-NEXT: return %0 : !linalg.range
// CHECK-LABEL: func @range_intersect(%{{.*}}: !linalg.range, %{{.*}}: !linalg.range) -> !linalg.range {
// CHECK-NEXT: %{{.*}} = linalg.range_intersect %{{.*}}, %{{.*}} : !linalg.range
// CHECK-NEXT: return %{{.*}} : !linalg.range
func @linalg_for(%arg0 : index, %arg1 : index, %arg2 : index) {
linalg.for %i0 = %arg0 to %arg1 step %arg2 {
@ -96,35 +96,35 @@ func @linalg_for(%arg0 : index, %arg1 : index, %arg2 : index) {
}
return
}
// CHECK-LABEL: func @linalg_for(%arg0: index, %arg1: index, %arg2: index) {
// CHECK-NEXT: linalg.for %i0 = %arg0 to %arg1 step %arg2 {
// CHECK-NEXT: linalg.for %i1 = %arg0 to %arg1 step %arg2 {
// CHECK-NEXT: %0 = cmpi "slt", %i0, %i1 : index
// CHECK-NEXT: %1 = select %0, %i0, %i1 : index
// CHECK-NEXT: %2 = cmpi "sge", %i0, %i1 : index
// CHECK-NEXT: %3 = select %2, %i0, %i1 : index
// CHECK-NEXT: linalg.for %i2 = %1 to %3 step %i1 {
// CHECK-LABEL: func @linalg_for(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK-NEXT: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK-NEXT: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: linalg.for %{{.*}} = %{{.*}} to %{{.*}} step %{{.*}} {
func @fill_view(%arg0: !linalg.view<?xf32>, %arg1: f32) {
linalg.fill(%arg0, %arg1) : !linalg.view<?xf32>, f32
return
}
// CHECK-LABEL: func @fill_view(%arg0: !linalg.view<?xf32>, %arg1: f32) {
// CHECK: linalg.fill(%arg0, %arg1) : !linalg.view<?xf32>, f32
// CHECK-LABEL: func @fill_view(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: f32) {
// CHECK: linalg.fill(%{{.*}}, %{{.*}}) : !linalg.view<?xf32>, f32
func @fill_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: f32) {
linalg.fill(%arg0, %arg1) : !linalg.view<?x?x?xf32>, f32
return
}
// CHECK-LABEL: func @fill_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: f32) {
// CHECK: linalg.fill(%arg0, %arg1) : !linalg.view<?x?x?xf32>, f32
// CHECK-LABEL: func @fill_view3(%{{.*}}: !linalg.view<?x?x?xf32>, %{{.*}}: f32) {
// CHECK: linalg.fill(%{{.*}}, %{{.*}}) : !linalg.view<?x?x?xf32>, f32
func @copy_view(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>) {
linalg.copy(%arg0, %arg1) : !linalg.view<?xf32>, !linalg.view<?xf32>
return
}
// CHECK-LABEL: func @copy_view(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>) {
// CHECK: linalg.copy(%arg0, %arg1) : !linalg.view<?xf32>, !linalg.view<?xf32>
// CHECK-LABEL: func @copy_view(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>) {
// CHECK: linalg.copy(%{{.*}}, %{{.*}}) : !linalg.view<?xf32>, !linalg.view<?xf32>
func @copy_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>) {
linalg.copy(%arg0, %arg1) {inputPermutation = (i, j, k) -> (i, k, j),
@ -132,31 +132,31 @@ func @copy_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>)
!linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>
return
}
// CHECK-LABEL: func @copy_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>) {
// CHECK: linalg.copy(%arg0, %arg1) {inputPermutation = #[[map0]], outputPermutation = #[[map1]]} : !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>
// CHECK-LABEL: func @copy_view3(%{{.*}}: !linalg.view<?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?xf32>) {
// CHECK: linalg.copy(%{{.*}}, %{{.*}}) {inputPermutation = #[[map0]], outputPermutation = #[[map1]]} : !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>
func @conv_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>, %arg2: !linalg.view<?x?x?xf32>) {
linalg.conv(%arg0, %arg1, %arg2) : !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>
return
}
// CHECK-LABEL: func @conv_view3(%arg0: !linalg.view<?x?x?xf32>, %arg1: !linalg.view<?x?x?xf32>, %arg2: !linalg.view<?x?x?xf32>) {
// CHECK: linalg.conv(%arg0, %arg1, %arg2) : !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>
// CHECK-LABEL: func @conv_view3(%{{.*}}: !linalg.view<?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?xf32>) {
// CHECK: linalg.conv(%{{.*}}, %{{.*}}, %{{.*}}) : !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>, !linalg.view<?x?x?xf32>
func @conv_view6(%arg0: !linalg.view<?x?x?x?x?x?xf32>, %arg1: !linalg.view<?x?x?x?x?x?xf32>, %arg2: !linalg.view<?x?x?x?x?x?xf32>) {
linalg.conv(%arg0, %arg1, %arg2) {dilations = [4, 4, 5, 5], strides = [2, 2, 3, 3]} : !linalg.view<?x?x?x?x?x?xf32>, !linalg.view<?x?x?x?x?x?xf32>, !linalg.view<?x?x?x?x?x?xf32>
return
}
// CHECK-LABEL: func @conv_view6(%arg0: !linalg.view<?x?x?x?x?x?xf32>, %arg1: !linalg.view<?x?x?x?x?x?xf32>, %arg2: !linalg.view<?x?x?x?x?x?xf32>) {
// CHECK: linalg.conv(%arg0, %arg1, %arg2) {dilations = [4, 4, 5, 5], strides = [2, 2, 3, 3]} : !linalg.view<?x?x?x?x?x?xf32>, !linalg.view<?x?x?x?x?x?xf32>, !linalg.view<?x?x?x?x?x?xf32>
// CHECK-LABEL: func @conv_view6(%{{.*}}: !linalg.view<?x?x?x?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?x?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?x?x?x?xf32>) {
// CHECK: linalg.conv(%{{.*}}, %{{.*}}, %{{.*}}) {dilations = [4, 4, 5, 5], strides = [2, 2, 3, 3]} : !linalg.view<?x?x?x?x?x?xf32>, !linalg.view<?x?x?x?x?x?xf32>, !linalg.view<?x?x?x?x?x?xf32>
func @subview(%arg0: !linalg.view<?x?xvector<3x4xi4>>) {
%c0 = constant 0 : index
%0 = linalg.subview %arg0[%c0, %c0, %c0, %c0, %c0, %c0] : !linalg.view<?x?xvector<3x4xi4>>
return
}
// CHECK-LABEL: func @subview(%arg0: !linalg.view<?x?xvector<3x4xi4>>) {
// CHECK: %c0 = constant 0 : index
// CHECK: %0 = linalg.subview %arg0[%c0, %c0, %c0, %c0, %c0, %c0] : !linalg.view<?x?xvector<3x4xi4>>
// CHECK-LABEL: func @subview(%{{.*}}: !linalg.view<?x?xvector<3x4xi4>>) {
// CHECK: %{{.*}} = constant 0 : index
// CHECK: %{{.*}} = linalg.subview %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}] : !linalg.view<?x?xvector<3x4xi4>>
func @const_buffer_view(%arg0: index, %arg1: index, %arg2: index) {
%c0 = linalg.buffer_alloc : !linalg.buffer<17xf32>

186
mlir/test/Linalg/tile.mlir
View File

@ -14,55 +14,55 @@ func @matmul(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?x?xf32>, %arg2:
linalg.matmul(%arg0, %arg1, %arg2) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
return
}
// TILE-2-LABEL: func @matmul(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?x?xf32>, %arg2: !linalg.view<?x?xf32>) {
// TILE-2: %[[M:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?xf32>
// TILE-2: linalg.for %i0 = %c0{{.*}} to %[[M]] step %c2 {
// TILE-2: %[[a:.*]] = affine.apply #[[UB0]](%i0)
// TILE-2: %[[K:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
// TILE-2: %[[sAi:.*]] = linalg.subview %arg0[%i0, %[[a]], %c1, %c0, %[[K]], %c1] : !linalg.view<?x?xf32>
// TILE-2: %[[c:.*]] = affine.apply #[[UB0]](%i0)
// TILE-2: %[[N:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?xf32>
// TILE-2: %[[sCi:.*]] = linalg.subview %arg2[%i0, %[[c]], %c1, %c0, %[[N]], %c1] : !linalg.view<?x?xf32>
// TILE-2: linalg.matmul(%[[sAi]], %arg1, %[[sCi]]) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
// TILE-2-LABEL: func @matmul(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?x?xf32>) {
// TILE-2: %[[M:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// TILE-2: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[M]] step %{{.*}} {
// TILE-2: %[[a:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-2: %[[K:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-2: %[[sAi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[a]], %{{.*}}, %{{.*}}, %[[K]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-2: %[[c:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-2: %[[N:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-2: %[[sCi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[c]], %{{.*}}, %{{.*}}, %[[N]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-2: linalg.matmul(%[[sAi]], %{{.*}}, %[[sCi]]) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
// TILE-02-LABEL: func @matmul(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?x?xf32>, %arg2: !linalg.view<?x?xf32>) {
// TILE-02-LABEL: func @matmul(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?x?xf32>) {
// TILE-02: %[[N:.*]] = linalg.dim %arg1, 1 : !linalg.view<?x?xf32>
// TILE-02: linalg.for %i0 = %c0 to %[[N]] step %c2 {
// TILE-02: %[[K:.*]] = linalg.dim %arg1, 0 : !linalg.view<?x?xf32>
// TILE-02: %[[b:.*]] = affine.apply #[[UB0]](%i0)
// TILE-02: %[[sBj:.*]] = linalg.subview %arg1[%c0, %[[K]], %c1, %i0, %[[b]], %c1] : !linalg.view<?x?xf32>
// TILE-02: %[[M:.*]] = linalg.dim %arg2, 0 : !linalg.view<?x?xf32>
// TILE-02: %[[c:.*]] = affine.apply #[[UB0]](%i0)
// TILE-02: %[[sCj:.*]] = linalg.subview %arg2[%c0, %[[M]], %c1, %i0, %[[c]], %c1] : !linalg.view<?x?xf32>
// TILE-02: linalg.matmul(%arg0, %[[sBj]], %[[sCj]]) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
// TILE-02: linalg.for %{{.*}} = %{{.*}} to %[[N]] step %{{.*}} {
// TILE-02: %[[K:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// TILE-02: %[[b:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-02: %[[sBj:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[K]], %{{.*}}, %{{.*}}, %[[b]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-02: %[[M:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// TILE-02: %[[c:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-02: %[[sCj:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[M]], %{{.*}}, %{{.*}}, %[[c]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-02: linalg.matmul(%{{.*}}, %[[sBj]], %[[sCj]]) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
// TILE-002-LABEL: func @matmul(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?x?xf32>, %arg2: !linalg.view<?x?xf32>) {
// TILE-002: %[[K:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
// TILE-002: linalg.for %i0 = %c0{{.*}} to %[[K]] step %c2 {
// TILE-002: %[[M:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?xf32>
// TILE-002: %[[a:.*]] = affine.apply #[[UB0]](%i0)
// TILE-002: %[[sAj:.*]] = linalg.subview %arg0[%c0, %[[M]], %c1, %i0, %[[a]], %c1] : !linalg.view<?x?xf32>
// TILE-002: %[[b:.*]] = affine.apply #[[UB0]](%i0)
// TILE-002: %[[N:.*]] = linalg.dim %arg1, 1 : !linalg.view<?x?xf32>
// TILE-002: %[[sBj:.*]] = linalg.subview %arg1[%i0, %[[b]], %c1, %c0, %[[N]], %c1] : !linalg.view<?x?xf32>
// TILE-002: linalg.matmul(%[[sAj]], %[[sBj]], %arg2) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
// TILE-002-LABEL: func @matmul(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?x?xf32>) {
// TILE-002: %[[K:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-002: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[K]] step %{{.*}} {
// TILE-002: %[[M:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// TILE-002: %[[a:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-002: %[[sAj:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[M]], %{{.*}}, %{{.*}}, %[[a]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-002: %[[b:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-002: %[[N:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-002: %[[sBj:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[b]], %{{.*}}, %{{.*}}, %[[N]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-002: linalg.matmul(%[[sAj]], %[[sBj]], %{{.*}}) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
// TILE-234-LABEL: func @matmul(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?x?xf32>, %arg2: !linalg.view<?x?xf32>) {
// TILE-234: %[[M:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?xf32>
// TILE-234: %[[K:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
// TILE-234: %[[N:.*]] = linalg.dim %arg1, 1 : !linalg.view<?x?xf32>
// TILE-234: linalg.for %i0 = %c0{{.*}} to %[[M]] step %c2 {
// TILE-234: linalg.for %i1 = %c0{{.*}} to %[[N]] step %c3 {
// TILE-234: linalg.for %i2 = %c0{{.*}} to %[[K]] step %c4 {
// TILE-234: %[[ai:.*]] = affine.apply #[[UB0]](%i0)
// TILE-234: %[[ak:.*]] = affine.apply #[[UB2]](%i2)
// TILE-234: %[[sAik:.*]] = linalg.subview %arg0[%i0, %[[ai]], %c1, %i2, %[[ak]], %c1] : !linalg.view<?x?xf32>
// TILE-234: %[[bk:.*]] = affine.apply #[[UB2]](%i2)
// TILE-234: %[[bj:.*]] = affine.apply #[[UB1]](%i1)
// TILE-234: %[[sBkj:.*]] = linalg.subview %arg1[%i2, %[[bk]], %c1, %i1, %[[bj]], %c1] : !linalg.view<?x?xf32>
// TILE-234: %[[ci:.*]] = affine.apply #[[UB0]](%i0)
// TILE-234: %[[cj:.*]] = affine.apply #[[UB1]](%i1)
// TILE-234: %[[sCij:.*]] = linalg.subview %arg2[%i0, %[[ci]], %c1, %i1, %[[cj]], %c1] : !linalg.view<?x?xf32>
// TILE-234-LABEL: func @matmul(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?x?xf32>) {
// TILE-234: %[[M:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// TILE-234: %[[K:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-234: %[[N:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-234: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[M]] step %{{.*}} {
// TILE-234: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[N]] step %{{.*}} {
// TILE-234: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[K]] step %{{.*}} {
// TILE-234: %[[ai:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-234: %[[ak:.*]] = affine.apply #[[UB2]](%{{.*}})
// TILE-234: %[[sAik:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[ai]], %{{.*}}, %{{.*}}, %[[ak]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-234: %[[bk:.*]] = affine.apply #[[UB2]](%{{.*}})
// TILE-234: %[[bj:.*]] = affine.apply #[[UB1]](%{{.*}})
// TILE-234: %[[sBkj:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[bk]], %{{.*}}, %{{.*}}, %[[bj]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-234: %[[ci:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-234: %[[cj:.*]] = affine.apply #[[UB1]](%{{.*}})
// TILE-234: %[[sCij:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[ci]], %{{.*}}, %{{.*}}, %[[cj]], %{{.*}}] : !linalg.view<?x?xf32>
//
// TILE-234: linalg.matmul(%[[sAik]], %[[sBkj]], %[[sCij]]) : !linalg.view<?x?xf32>, !linalg.view<?x?xf32>, !linalg.view<?x?xf32>
@ -70,41 +70,41 @@ func @matvec(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !l
linalg.matvec(%arg0, %arg1, %arg2) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
return
}
// TILE-2-LABEL: func @matvec(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<?xf32>) {
// TILE-2: %[[M:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?xf32>
// TILE-2: linalg.for %i0 = %c0{{.*}} to %[[M]] step %c2 {
// TILE-2: %[[a:.*]] = affine.apply #[[UB0]](%i0)
// TILE-2: %[[N:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
// TILE-2: %[[sAi:.*]] = linalg.subview %arg0[%i0, %[[a]], %c1, %c0, %[[N]], %c1] : !linalg.view<?x?xf32>
// TILE-2: %[[c:.*]] = affine.apply #[[UB0]](%i0)
// TILE-2: %[[sCi:.*]] = linalg.subview %arg2[%i0, %[[c]], %c1] : !linalg.view<?xf32>
// TILE-2: linalg.matvec(%[[sAi]], %arg1, %[[sCi]]) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
// TILE-2-LABEL: func @matvec(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>) {
// TILE-2: %[[M:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// TILE-2: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[M]] step %{{.*}} {
// TILE-2: %[[a:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-2: %[[N:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-2: %[[sAi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[a]], %{{.*}}, %{{.*}}, %[[N]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-2: %[[c:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-2: %[[sCi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[c]], %{{.*}}] : !linalg.view<?xf32>
// TILE-2: linalg.matvec(%[[sAi]], %{{.*}}, %[[sCi]]) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
// TILE-02-LABEL: func @matvec(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<?xf32>) {
// TILE-02: %[[K:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
// TILE-02: linalg.for %i0 = %c0{{.*}} to %[[K]] step %c2 {
// TILE-02: %[[M:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?xf32>
// TILE-02: %[[a:.*]] = affine.apply #[[UB0]](%i0)
// TILE-02: %[[sAj:.*]] = linalg.subview %arg0[%c0, %[[M]], %c1, %i0, %[[a]], %c1] : !linalg.view<?x?xf32>
// TILE-02: %[[b:.*]] = affine.apply #[[UB0]](%i0)
// TILE-02: %[[sBj:.*]] = linalg.subview %arg1[%i0, %[[b]], %c1] : !linalg.view<?xf32>
// TILE-02: linalg.matvec(%[[sAj]], %[[sBj]], %arg2) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
// TILE-02-LABEL: func @matvec(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>) {
// TILE-02: %[[K:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-02: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[K]] step %{{.*}} {
// TILE-02: %[[M:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// TILE-02: %[[a:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-02: %[[sAj:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[M]], %{{.*}}, %{{.*}}, %[[a]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-02: %[[b:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-02: %[[sBj:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[b]], %{{.*}}] : !linalg.view<?xf32>
// TILE-02: linalg.matvec(%[[sAj]], %[[sBj]], %{{.*}}) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
// TILE-002-LABEL: func @matvec(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<?xf32>) {
// TILE-002-LABEL: func @matvec(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>) {
// TILE-002-NOT: linalg.for
// TILE-234-LABEL: func @matvec(%arg0: !linalg.view<?x?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<?xf32>) {
// TILE-234: %[[M:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?xf32>
// TILE-234: %[[K:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?xf32>
// TILE-234: linalg.for %i0 = %c0{{.*}} to %[[M]] step %c2 {
// TILE-234: linalg.for %i1 = %c0{{.*}} to %[[K]] step %c3 {
// TILE-234: %[[ai:.*]] = affine.apply #[[UB0]](%i0)
// TILE-234: %[[aj:.*]] = affine.apply #[[UB1]](%i1)
// TILE-234: %[[sAij:.*]] = linalg.subview %arg0[%i0, %[[ai]], %c1, %i1, %[[aj]], %c1] : !linalg.view<?x?xf32>
// TILE-234: %[[bj:.*]] = affine.apply #[[UB1]](%i1)
// TILE-234: %[[sBj:.*]] = linalg.subview %arg1[%i1, %[[bj]], %c1] : !linalg.view<?xf32>
// TILE-234: %[[ci:.*]] = affine.apply #[[UB0]](%i0)
// TILE-234: %[[sCi:.*]] = linalg.subview %arg2[%i0, %[[ci]], %c1] : !linalg.view<?xf32>
// TILE-234-LABEL: func @matvec(%{{.*}}: !linalg.view<?x?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>) {
// TILE-234: %[[M:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?xf32>
// TILE-234: %[[K:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?xf32>
// TILE-234: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[M]] step %{{.*}} {
// TILE-234: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[K]] step %{{.*}} {
// TILE-234: %[[ai:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-234: %[[aj:.*]] = affine.apply #[[UB1]](%{{.*}})
// TILE-234: %[[sAij:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[ai]], %{{.*}}, %{{.*}}, %[[aj]], %{{.*}}] : !linalg.view<?x?xf32>
// TILE-234: %[[bj:.*]] = affine.apply #[[UB1]](%{{.*}})
// TILE-234: %[[sBj:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[bj]], %{{.*}}] : !linalg.view<?xf32>
// TILE-234: %[[ci:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-234: %[[sCi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[ci]], %{{.*}}] : !linalg.view<?xf32>
//
// TILE-234: linalg.matvec(%[[sAij]], %[[sBj]], %[[sCi]]) : !linalg.view<?x?xf32>, !linalg.view<?xf32>, !linalg.view<?xf32>
@ -112,26 +112,26 @@ func @dot(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg
linalg.dot(%arg0, %arg1, %arg2) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
return
}
// TILE-2-LABEL: func @dot(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<f32>) {
// TILE-2: %[[M:.*]] = linalg.dim %arg0, 0 : !linalg.view<?xf32>
// TILE-2: linalg.for %i0 = %c0{{.*}} to %[[M]] step %c2 {
// TILE-2: %[[a:.*]] = affine.apply #[[UB0]](%i0)
// TILE-2: %[[sAi:.*]] = linalg.subview %arg0[%i0, %[[a]], %c1] : !linalg.view<?xf32>
// TILE-2: %[[b:.*]] = affine.apply #[[UB0]](%i0)
// TILE-2: %[[sBi:.*]] = linalg.subview %arg1[%i0, %[[b]], %c1] : !linalg.view<?xf32>
// TILE-2-LABEL: func @dot(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<f32>) {
// TILE-2: %[[M:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?xf32>
// TILE-2: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[M]] step %{{.*}} {
// TILE-2: %[[a:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-2: %[[sAi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[a]], %{{.*}}] : !linalg.view<?xf32>
// TILE-2: %[[b:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-2: %[[sBi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[b]], %{{.*}}] : !linalg.view<?xf32>
// TILE-2: linalg.dot(%[[sAi]], %[[sBi]], {{.*}}) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
// TILE-02-LABEL: func @dot(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<f32>) {
// TILE-02-LABEL: func @dot(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<f32>) {
// TILE-02-NOT: linalg.for
// TILE-002-LABEL: func @dot(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<f32>) {
// TILE-002-LABEL: func @dot(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<f32>) {
// TILE-002-NOT: linalg.for
// TILE-234-LABEL: func @dot(%arg0: !linalg.view<?xf32>, %arg1: !linalg.view<?xf32>, %arg2: !linalg.view<f32>) {
// TILE-234: %[[K:.*]] = linalg.dim %arg0, 0 : !linalg.view<?xf32>
// TILE-234: linalg.for %i0 = %c0{{.*}} to %[[K]] step %c2 {
// TILE-234: %[[a:.*]] = affine.apply #[[UB0]](%i0)
// TILE-234: %[[sAi:.*]] = linalg.subview %arg0[%i0, %[[a]], %c1] : !linalg.view<?xf32>
// TILE-234: %[[b:.*]] = affine.apply #[[UB0]](%i0)
// TILE-234: %[[sBi:.*]] = linalg.subview %arg1[%i0, %[[b]], %c1] : !linalg.view<?xf32>
// TILE-234: linalg.dot(%[[sAi]], %[[sBi]], %arg2) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>
// TILE-234-LABEL: func @dot(%{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<?xf32>, %{{.*}}: !linalg.view<f32>) {
// TILE-234: %[[K:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?xf32>
// TILE-234: linalg.for %{{.*}} = %{{.*}}{{.*}} to %[[K]] step %{{.*}} {
// TILE-234: %[[a:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-234: %[[sAi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[a]], %{{.*}}] : !linalg.view<?xf32>
// TILE-234: %[[b:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-234: %[[sBi:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[b]], %{{.*}}] : !linalg.view<?xf32>
// TILE-234: linalg.dot(%[[sAi]], %[[sBi]], %{{.*}}) : !linalg.view<?xf32>, !linalg.view<?xf32>, !linalg.view<f32>

48
mlir/test/Linalg/tile_conv.mlir
View File

@ -9,31 +9,31 @@ func @conv(%arg0: !linalg.view<?x?x?x?xf32>, %arg1: !linalg.view<?x?x?x?xf32>, %
linalg.conv(%arg0, %arg1, %arg2) {dilations = [10, 20], strides = [30, 40]} : !linalg.view<?x?x?x?xf32>, !linalg.view<?x?x?x?xf32>, !linalg.view<?x?x?x?xf32>
return
}
// TILE-23004-LABEL: func @conv(%arg0: !linalg.view<?x?x?x?xf32>, %arg1: !linalg.view<?x?x?x?xf32>, %arg2: !linalg.view<?x?x?x?xf32>) {
// TILE-23004: %[[Q:.*]] = linalg.dim %arg0, 2 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[B:.*]] = linalg.dim %arg1, 0 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[PaddedInput0:.*]] = linalg.dim %arg1, 1 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[X0:.*]] = linalg.dim %arg2, 1 : !linalg.view<?x?x?x?xf32>
// TILE-23004: linalg.for %i0 = %c0 to %[[B]] step %c2 {
// TILE-23004: linalg.for %i1 = %c0 to %[[X0]] step %c3 {
// TILE-23004: linalg.for %i2 = %c0 to %[[Q]] step %c4 {
// TILE-23004: %[[Z0:.*]] = linalg.dim %arg0, 0 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[Z1:.*]] = linalg.dim %arg0, 1 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[I2p4:.*]] = affine.apply #[[UB2]](%i2)
// TILE-23004: %[[K:.*]] = linalg.dim %arg0, 3 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[FilterView:.*]] = linalg.subview %arg0[%c0, %[[Z0]], %c1, %c0, %[[Z1]], %c1, %i2, %[[I2p4]], %c1, %c0, %[[K]], %c1] : !linalg.view<?x?x?x?xf32>
// TILE-23004-LABEL: func @conv(%{{.*}}: !linalg.view<?x?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?x?xf32>, %{{.*}}: !linalg.view<?x?x?x?xf32>) {
// TILE-23004: %[[Q:.*]] = linalg.dim %{{.*}}, 2 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[B:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[PaddedInput0:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[X0:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?x?x?xf32>
// TILE-23004: linalg.for %{{.*}} = %{{.*}} to %[[B]] step %{{.*}} {
// TILE-23004: linalg.for %{{.*}} = %{{.*}} to %[[X0]] step %{{.*}} {
// TILE-23004: linalg.for %{{.*}} = %{{.*}} to %[[Q]] step %{{.*}} {
// TILE-23004: %[[Z0:.*]] = linalg.dim %{{.*}}, 0 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[Z1:.*]] = linalg.dim %{{.*}}, 1 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[I2p4:.*]] = affine.apply #[[UB2]](%{{.*}})
// TILE-23004: %[[K:.*]] = linalg.dim %{{.*}}, 3 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[FilterView:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[Z0]], %{{.*}}, %{{.*}}, %[[Z1]], %{{.*}}, %{{.*}}, %[[I2p4]], %{{.*}}, %{{.*}}, %[[K]], %{{.*}}] : !linalg.view<?x?x?x?xf32>
//
// TILE-23004: %[[I0p3:.*]] = affine.apply #[[UB0]](%i0)
// TILE-23004: %[[I1:.*]] = affine.apply #[[D0x30pS0x10]](%i1)[%c0]
// TILE-23004: %[[I1pStep:.*]] = affine.apply #[[D0x30pS0x10p90]](%i1)[%[[PaddedInput0]]]
// TILE-23004: %[[SZ2:.*]] = linalg.dim %arg1, 2 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[I2p2:.*]] = affine.apply #[[UB2]](%i2)
// TILE-23004: %[[InputView:.*]] = linalg.subview %arg1[%i0, %[[I0p3]], %c1, %[[I1]], %[[I1pStep]], %c1, %c0, %[[SZ2]], %c1, %i2, %[[I2p2]], %c1] : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[I0p3:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-23004: %[[I1:.*]] = affine.apply #[[D0x30pS0x10]](%{{.*}})[%{{.*}}]
// TILE-23004: %[[I1pStep:.*]] = affine.apply #[[D0x30pS0x10p90]](%{{.*}})[%[[PaddedInput0]]]
// TILE-23004: %[[SZ2:.*]] = linalg.dim %{{.*}}, 2 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[I2p2:.*]] = affine.apply #[[UB2]](%{{.*}})
// TILE-23004: %[[InputView:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[I0p3]], %{{.*}}, %[[I1]], %[[I1pStep]], %{{.*}}, %{{.*}}, %[[SZ2]], %{{.*}}, %{{.*}}, %[[I2p2]], %{{.*}}] : !linalg.view<?x?x?x?xf32>
//
// TILE-23004: %[[B:.*]] = affine.apply #[[UB0]](%i0)
// TILE-23004: %[[I1p3:.*]] = affine.apply #[[UB1]](%i1)
// TILE-23004: %[[X0:.*]] = linalg.dim %arg2, 2 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[X1:.*]] = linalg.dim %arg2, 3 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[OutputView:.*]] = linalg.subview %arg2[%i0, %[[B]], %c1, %i1, %[[I1p3]], %c1, %c0, %[[X0]], %c1, %c0, %[[X1]], %c1] : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[B:.*]] = affine.apply #[[UB0]](%{{.*}})
// TILE-23004: %[[I1p3:.*]] = affine.apply #[[UB1]](%{{.*}})
// TILE-23004: %[[X0:.*]] = linalg.dim %{{.*}}, 2 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[X1:.*]] = linalg.dim %{{.*}}, 3 : !linalg.view<?x?x?x?xf32>
// TILE-23004: %[[OutputView:.*]] = linalg.subview %{{.*}}[%{{.*}}, %[[B]], %{{.*}}, %{{.*}}, %[[I1p3]], %{{.*}}, %{{.*}}, %[[X0]], %{{.*}}, %{{.*}}, %[[X1]], %{{.*}}] : !linalg.view<?x?x?x?xf32>
//
// TILE-23004: linalg.conv(%[[FilterView]], %[[InputView]], %[[OutputView]]) : !linalg.view<?x?x?x?xf32>, !linalg.view<?x?x?x?xf32>, !linalg.view<?x?x?x?xf32>

48
mlir/test/Transforms/Vectorize/lower_vector_transfers.mlir
View File

@ -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

30
mlir/test/Transforms/Vectorize/materialize.mlir
View File

@ -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 {

12
mlir/test/Transforms/Vectorize/materialize_vectors_1d_to_1d.mlir
View File

@ -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

40
mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_1d.mlir
View File

@ -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

32
mlir/test/Transforms/Vectorize/materialize_vectors_2d_to_2d.mlir
View File

@ -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

28
mlir/test/Transforms/Vectorize/normalize_maps.mlir
View File

@ -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
}

136
mlir/test/Transforms/Vectorize/vectorize_1d.mlir
View File

@ -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>

40
mlir/test/Transforms/Vectorize/vectorize_2d.mlir
View File

@ -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) {

12
mlir/test/Transforms/Vectorize/vectorize_3d.mlir
View File

@ -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 {

14
mlir/test/Transforms/Vectorize/vectorize_outer_loop_2d.mlir
View File

@ -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 {

32
mlir/test/Transforms/Vectorize/vectorize_outer_loop_transpose_2d.mlir
View File

@ -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 {

32
mlir/test/Transforms/Vectorize/vectorize_transpose_2d.mlir
View File

@ -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 {

18
mlir/test/Transforms/canonicalize.mlir
View File

@ -338,18 +338,18 @@ func @dyn_shape_fold(%L : index, %M : index) -> (memref<? x ? x i32>, memref<? x
// CHECK-NEXT: %2 = alloc() : memref<512x1024xi32>
%c = alloc(%K, %N) : memref<? x ? x i32>
// CHECK: affine.for %i0 =
// CHECK: affine.for
affine.for %i = 0 to %L {
// CHECK-NEXT: affine.for %i1 =
// CHECK-NEXT: affine.for
affine.for %j = 0 to 10 {
// CHECK-NEXT: %4 = load %0[%i0, %i1] : memref<?x1024xf32>
// CHECK-NEXT: store %4, %1[%c0, %c0, %i0, %i1, %c0] : memref<4x1024x8x512x?xf32>
// CHECK-NEXT: load %0[%arg2, %arg3] : memref<?x1024xf32>
// CHECK-NEXT: store %{{.*}}, %1[%c0, %c0, %arg2, %arg3, %c0] : memref<4x1024x8x512x?xf32>
%v = load %a[%i, %j] : memref<?x?xf32>
store %v, %b[%zero, %zero, %i, %j, %zero] : memref<4x?x8x?x?xf32>
}
}
// CHECK: %5 = alloc() : memref<9x9xf32>
// CHECK: alloc() : memref<9x9xf32>
%d = alloc(%nine, %nine) : memref<? x ? x f32>
return %c, %d : memref<? x ? x i32>, memref<? x ? x f32>
@ -367,11 +367,11 @@ func @merge_constants() -> (index, index) {
// CHECK-LABEL: func @hoist_constant
func @hoist_constant(%arg0: memref<8xi32>) {
// CHECK-NEXT: %c42_i32 = constant 42 : i32
// CHECK-NEXT: affine.for %i0 = 0 to 8 {
affine.for %i0 = 0 to 8 {
// CHECK-NEXT: store %c42_i32, %arg0[%i0]
// CHECK-NEXT: affine.for %arg1 = 0 to 8 {
affine.for %arg1 = 0 to 8 {
// CHECK-NEXT: store %c42_i32, %arg0[%arg1]
%c42_i32 = constant 42 : i32
store %c42_i32, %arg0[%i0] : memref<8xi32>
store %c42_i32, %arg0[%arg1] : memref<8xi32>
}
return
}

4
mlir/test/Transforms/constant-fold.mlir
View File

@ -5,8 +5,8 @@
// CHECK-LABEL: @test(%arg0: memref<f32>) {
func @test(%p : memref<f32>) {
// CHECK: %cst = constant 6.000000e+00 : f32
affine.for %i0 = 0 to 128 {
affine.for %i1 = 0 to 8 { // CHECK: affine.for %i1 = 0 to 8 {
affine.for %arg1 = 0 to 128 {
affine.for %arg2 = 0 to 8 { // CHECK: affine.for %{{.*}} = 0 to 8 {
%0 = constant 4.5 : f32
%1 = constant 1.5 : f32

20
mlir/test/Transforms/cse.mlir
View File

@ -113,7 +113,7 @@ func @down_propagate_for() {
// CHECK: %c1_i32 = constant 1 : i32
%0 = constant 1 : i32
// CHECK-NEXT: affine.for %i0 = 0 to 4 {
// CHECK-NEXT: affine.for {{.*}} = 0 to 4 {
affine.for %i = 0 to 4 {
// CHECK-NEXT: "foo"(%c1_i32, %c1_i32) : (i32, i32) -> ()
%1 = constant 1 : i32
@ -145,16 +145,16 @@ func @down_propagate() -> i32 {
/// Check that operation definitions are NOT propagated up the dominance tree.
// CHECK-LABEL: @up_propagate_for
func @up_propagate_for() -> i32 {
// CHECK: affine.for %i0 = 0 to 4 {
// CHECK: affine.for {{.*}} = 0 to 4 {
affine.for %i = 0 to 4 {
// CHECK-NEXT: %c1_i32 = constant 1 : i32
// CHECK-NEXT: "foo"(%c1_i32) : (i32) -> ()
// CHECK-NEXT: %c1_i32_0 = constant 1 : i32
// CHECK-NEXT: "foo"(%c1_i32_0) : (i32) -> ()
%0 = constant 1 : i32
"foo"(%0) : (i32) -> ()
}
// CHECK: %c1_i32_0 = constant 1 : i32
// CHECK-NEXT: return %c1_i32_0 : i32
// CHECK: %c1_i32 = constant 1 : i32
// CHECK-NEXT: return %c1_i32 : i32
%1 = constant 1 : i32
return %1 : i32
}
@ -200,16 +200,16 @@ func @up_propagate_region() -> i32 {
%1 = constant 0 : i32
%true = constant 1 : i1
cond_br %true, ^bb2, ^bb3(%1 : i32)
cond_br %true, ^bb1, ^bb2(%1 : i32)
^bb2: // CHECK: ^bb2:
^bb1: // CHECK: ^bb1:
// CHECK-NEXT: %c1_i32 = constant 1 : i32
// CHECK-NEXT: br
%c1_i32 = constant 1 : i32
br ^bb3(%c1_i32 : i32)
br ^bb2(%c1_i32 : i32)
^bb3(%arg : i32): // CHECK: ^bb3(%1: i32):
^bb2(%arg : i32): // CHECK: ^bb2(%1: i32):
// CHECK-NEXT: %c1_i32_0 = constant 1 : i32
// CHECK-NEXT: %2 = addi %1, %c1_i32_0 : i32
// CHECK-NEXT: "foo.yield"(%2) : (i32) -> ()

362
mlir/test/Transforms/dma-generate.mlir
View File

@ -22,33 +22,33 @@ func @loop_nest_1d() {
%B = alloc() : memref<512 x f32>
%F = alloc() : memref<256 x f32, 2>
// First DMA buffer.
// CHECK: %0 = alloc() : memref<256xf32>
// CHECK: %3 = alloc() : memref<256xf32, 2>
// CHECK: %{{.*}} = alloc() : memref<256xf32>
// CHECK: %{{.*}} = alloc() : memref<256xf32, 2>
// Tag for first DMA.
// CHECK: %4 = alloc() : memref<1xi32>
// CHECK: %{{.*}} = alloc() : memref<1xi32>
// First DMA transfer.
// CHECK: affine.dma_start %0[%c0], %3[%c0], %4[%c0], %c256_1 : memref<256xf32>, memref<256xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %4[%c0], %c256_1 : memref<1xi32>
// CHECK: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<256xf32, 2>, memref<1xi32>
// CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// Second DMA buffer.
// CHECK: %5 = alloc() : memref<256xf32, 2>
// CHECK: %{{.*}} = alloc() : memref<256xf32, 2>
// Tag for second DMA.
// CHECK: %6 = alloc() : memref<1xi32>
// CHECK: %{{.*}} = alloc() : memref<1xi32>
// Second DMA transfer.
// CHECK: affine.dma_start %1[%c256], %5[%c0], %6[%c0], %c256_0 : memref<512xf32>, memref<256xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %6[%c0], %c256_0 : memref<1xi32>
// CHECK: affine.for %i0 = 0 to 256 {
// CHECK-NEXT: %7 = affine.load %3[%i0] : memref<256xf32, 2>
// CHECK: %8 = affine.apply [[MAP_PLUS_256]](%i0)
// Buffer for '%B' in faster memref space is smaller size: 256xf32
// Affine map for 'affine.load %5' is composed: %i0 + 256 - 256 = %i0.
// CHECK-NEXT: %9 = affine.load %5[%i0] : memref<256xf32, 2>
// CHECK: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<512xf32>, memref<256xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK: affine.for %{{.*}} = 0 to 256 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
// CHECK: %{{.*}} = affine.apply [[MAP_PLUS_256]](%{{.*}})
// Buffer for '%{{.*}}' in faster memref space is smaller size: 256xf32
// Affine map for 'affine.load %{{.*}}' is composed: %{{.*}} + 256 - 256 = %{{.*}}.
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
// Already in faster memory space.
// CHECK: %10 = affine.load %2[%i0] : memref<256xf32, 2>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<256xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: dealloc %6 : memref<1xi32>
// CHECK-NEXT: dealloc %5 : memref<256xf32, 2>
// CHECK-NEXT: dealloc %4 : memref<1xi32>
// CHECK-NEXT: dealloc %3 : memref<256xf32, 2>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<256xf32, 2>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<256xf32, 2>
// CHECK-NEXT: return
affine.for %i = 0 to 256 {
affine.load %A[%i] : memref<256 x f32>
@ -62,7 +62,7 @@ func @loop_nest_1d() {
// -----
// CHECK-LABEL: func @loop_nest_high_d
// CHECK: %c16384 = constant 16384 : index
// CHECK: %{{.*}} = constant 16384 : index
// CHECK-DAG: [[BUFB:%[0-9]+]] = alloc() : memref<512x32xf32, 2>
// CHECK-DAG: [[BUFA:%[0-9]+]] = alloc() : memref<512x32xf32, 2>
// CHECK-DAG: [[BUFC:%[0-9]+]] = alloc() : memref<512x32xf32, 2>
@ -71,41 +71,41 @@ func @loop_nest_1d() {
// CHECK-DAG: [[TAGC:%[0-9]+]] = alloc() : memref<1xi32>
// CHECK-DAG: [[TAGC_W:%[0-9]+]] = alloc() : memref<1xi32>
// INCOMING DMA for B
// CHECK-DAG: affine.dma_start %arg1[%c0, %c0], [[BUFB]][%c0, %c0], [[TAGB]][%c0], %c16384_2 : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>
// CHECK-DAG: affine.dma_wait [[TAGB]][%c0], %c16384_2 : memref<1xi32>
// CHECK-DAG: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], [[BUFB]][%{{.*}}, %{{.*}}], [[TAGB]][%{{.*}}], %{{.*}} : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>
// CHECK-DAG: affine.dma_wait [[TAGB]][%{{.*}}], %{{.*}} : memref<1xi32>
// INCOMING DMA for A.
// CHECK-DAG: affine.dma_start %arg0[%c0, %c0], [[BUFA]][%c0, %c0], [[TAGA]][%c0], %c16384_1 : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>
// CHECK-DAG: affine.dma_wait [[TAGA]][%c0], %c16384_1 : memref<1xi32>
// CHECK-DAG: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], [[BUFA]][%{{.*}}, %{{.*}}], [[TAGA]][%{{.*}}], %{{.*}} : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>
// CHECK-DAG: affine.dma_wait [[TAGA]][%{{.*}}], %{{.*}} : memref<1xi32>
// INCOMING DMA for C.
// CHECK-DAG: affine.dma_start %arg2[%c0, %c0], [[BUFC]][%c0, %c0], [[TAGC]][%c0], %c16384_0 : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>
// CHECK-DAG: affine.dma_wait [[TAGC]][%c0], %c16384_0 : memref<1xi32>
// CHECK-NEXT: affine.for %i0 = 0 to 32 {
// CHECK-NEXT: affine.for %i1 = 0 to 32 {
// CHECK-NEXT: affine.for %i2 = 0 to 32 {
// CHECK-NEXT: affine.for %i3 = 0 to 16 {
// CHECK-NEXT: %7 = affine.apply #map{{[0-9]+}}(%i1, %i3)
// CHECK-NEXT: %8 = affine.load [[BUFB]][%i1 * 16 + %i3, %i0] : memref<512x32xf32, 2>
// CHECK-NEXT: "foo"(%8) : (f32) -> ()
// CHECK-DAG: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], [[BUFC]][%{{.*}}, %{{.*}}], [[TAGC]][%{{.*}}], %{{.*}} : memref<512x32xf32>, memref<512x32xf32, 2>, memref<1xi32>
// CHECK-DAG: affine.dma_wait [[TAGC]][%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 32 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 32 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 32 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load [[BUFB]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
// CHECK-NEXT: "foo"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: affine.for %i4 = 0 to 16 {
// CHECK-NEXT: %9 = affine.apply #map{{[0-9]+}}(%i2, %i4)
// CHECK-NEXT: %10 = affine.load [[BUFA]][%i2 * 16 + %i4, %i1] : memref<512x32xf32, 2>
// CHECK-NEXT: "bar"(%10) : (f32) -> ()
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load [[BUFA]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
// CHECK-NEXT: "bar"(%{{.*}}) : (f32) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: affine.for %i5 = 0 to 16 {
// CHECK-NEXT: %11 = "abc_compute"() : () -> f32
// CHECK-NEXT: %12 = affine.apply #map{{[0-9]+}}(%i2, %i5)
// CHECK-NEXT: %13 = affine.load [[BUFC]][%i2 * 16 + %i5, %i0] : memref<512x32xf32, 2>
// CHECK-NEXT: %14 = "addf32"(%11, %13) : (f32, f32) -> f32
// CHECK-NEXT: affine.store %14, [[BUFC]][%i2 * 16 + %i5, %i0] : memref<512x32xf32, 2>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 16 {
// CHECK-NEXT: %{{.*}} = "abc_compute"() : () -> f32
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load [[BUFC]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
// CHECK-NEXT: %{{.*}} = "addf32"(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
// CHECK-NEXT: affine.store %{{.*}}, [[BUFC]][%{{.*}} * 16 + %{{.*}}, %{{.*}}] : memref<512x32xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: "foobar"() : () -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// OUTGOING DMA for C.
// CHECK-NEXT: affine.dma_start [[BUFC]][%c0, %c0], %arg2[%c0, %c0], [[TAGC_W]][%c0], %c16384 : memref<512x32xf32, 2>, memref<512x32xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait [[TAGC_W]][%c0], %c16384 : memref<1xi32>
// CHECK-NEXT: affine.dma_start [[BUFC]][%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], [[TAGC_W]][%{{.*}}], %{{.*}} : memref<512x32xf32, 2>, memref<512x32xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait [[TAGC_W]][%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc [[TAGC_W]] : memref<1xi32>
// CHECK-NEXT: dealloc [[TAGC]] : memref<1xi32>
// CHECK-NEXT: dealloc [[BUFC]] : memref<512x32xf32, 2>
@ -153,20 +153,20 @@ func @loop_nest_high_d(%A: memref<512 x 32 x f32>,
// region within a 256 x 8 memref.
//
// CHECK-LABEL: func @loop_nest_modulo() {
// CHECK: %0 = alloc() : memref<256x8xf32>
// CHECK-NEXT: affine.for %i0 = 0 to 32 step 4 {
// CHECK-NEXT: %1 = affine.apply #map{{[0-9]+}}(%i0)
// CHECK-NEXT: %2 = alloc() : memref<1x2xf32, 2>
// CHECK-NEXT: %3 = alloc() : memref<1xi32>
// Composition of the affine map for '%0' causes '%c0' to be added as a symbol.
// CHECK-NEXT: affine.dma_start %0[%i0, symbol(%c0)], %2[%c0, %c0], %3[%c0], %c2 : memref<256x8xf32>, memref<1x2xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %3[%c0], %c2 : memref<1xi32>
// CHECK-NEXT: affine.for %i1 = 0 to 8 {
// CHECK: %{{.*}} = alloc() : memref<256x8xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 32 step 4 {
// CHECK-NEXT: %{{.*}} = affine.apply #map{{[0-9]+}}(%{{.*}})
// CHECK-NEXT: %{{.*}} = alloc() : memref<1x2xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// Composition of the affine map for '%{{.*}}' causes '%{{.*}}' to be added as a symbol.
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, symbol(%{{.*}})], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256x8xf32>, memref<1x2xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 8 {
// ...
// ...
// CHECK: }
// CHECK-NEXT: dealloc %3 : memref<1xi32>
// CHECK-NEXT: dealloc %2 : memref<1x2xf32, 2>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<1x2xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: return
func @loop_nest_modulo() {
@ -191,16 +191,16 @@ func @loop_nest_tiled() -> memref<256x1024xf32> {
%0 = alloc() : memref<256x1024xf32>
affine.for %i0 = 0 to 256 step 32 {
affine.for %i1 = 0 to 1024 step 32 {
// CHECK: %3 = alloc() : memref<32x32xf32, 2>
// CHECK-NEXT: %4 = alloc() : memref<1xi32>
// CHECK: %{{.*}} = alloc() : memref<32x32xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// Strided DMA here: 32 x 32 tile in a 256 x 1024 memref.
// CHECK-NEXT: affine.dma_start %0[%i0, %i1], %3[%c0, %c0], %4[%c0], %c1024, %c1024_0, %c32 : memref<256x1024xf32>, memref<32x32xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<256x1024xf32>, memref<32x32xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait
// CHECK-NEXT: affine.for %i2 = #map
// CHECK-NEXT: affine.for %i3 = #map
// CHECK-NEXT: affine.for %{{.*}} = #map
// CHECK-NEXT: affine.for %{{.*}} = #map
affine.for %i2 = (d0) -> (d0)(%i0) to (d0) -> (d0 + 32)(%i0) {
affine.for %i3 = (d0) -> (d0)(%i1) to (d0) -> (d0 + 32)(%i1) {
// CHECK: %5 = affine.load %3[-%i0 + %i2, -%i1 + %i3] : memref<32x32xf32, 2>
// CHECK: %{{.*}} = affine.load %{{.*}}[-%{{.*}} + %{{.*}}, -%{{.*}} + %{{.*}}] : memref<32x32xf32, 2>
%1 = affine.load %0[%i2, %i3] : memref<256x1024xf32>
} // CHECK-NEXT: }
}
@ -215,14 +215,14 @@ func @loop_nest_tiled() -> memref<256x1024xf32> {
func @dma_constant_dim_access(%A : memref<100x100xf32>) {
%one = constant 1 : index
%N = constant 100 : index
// CHECK: %0 = alloc() : memref<1x100xf32, 2>
// CHECK-NEXT: %1 = alloc() : memref<1xi32>
// CHECK: %{{.*}} = alloc() : memref<1x100xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// No strided DMA needed here.
// CHECK: affine.dma_start %arg0[%c1, %c0], %0[%c0, %c0], %1[%c0], %c100 : memref<100x100xf32>, memref<1x100xf32, 2>,
// CHECK-NEXT: affine.dma_wait %1[%c0], %c100 : memref<1xi32>
// CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<1x100xf32, 2>,
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
affine.for %i = 0 to 100 {
affine.for %j = 0 to ()[s0] -> (s0) ()[%N] {
// CHECK: %2 = affine.load %0[symbol(%c1_0) - 1, %i1] : memref<1x100xf32, 2>
// CHECK: %{{.*}} = affine.load %{{.*}}[symbol(%{{.*}}) - 1, %{{.*}}] : memref<1x100xf32, 2>
affine.load %A[%one, %j] : memref<100 x 100 x f32>
}
}
@ -243,14 +243,14 @@ func @dma_with_symbolic_accesses(%A : memref<100x100xf32>, %M : index) {
}
}
return
// CHECK: %1 = alloc() : memref<100x100xf32, 2>
// CHECK-NEXT: %2 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %arg0[symbol(%c0), symbol(%arg1) + 9], %1[%c0, %c0], %2[%c0], %c10000
// CHECK-NEXT: affine.dma_wait %2[%c0], %c10000
// CHECK-NEXT: affine.for %i0 = 0 to 100 {
// CHECK-NEXT: affine.for %i1 = 0 to 100 {
// CHECK-NEXT: %3 = affine.apply [[MAP_SYM_SHIFT]](%i0, %i1)[%arg1, %c9]
// CHECK-NEXT: %4 = affine.load %1[%i0, %i1 + symbol(%c9) - 9] : memref<100x100xf32, 2>
// CHECK: %{{.*}} = alloc() : memref<100x100xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[symbol(%{{.*}}), symbol(%{{.*}}) + 9], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}}
// CHECK-NEXT: affine.for %{{.*}} = 0 to 100 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 100 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_SYM_SHIFT]](%{{.*}}, %{{.*}})[%{{.*}}, %{{.*}}]
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}} + symbol(%{{.*}}) - 9] : memref<100x100xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK: return
@ -263,10 +263,10 @@ func @dma_with_symbolic_loop_bounds(%A : memref<100x100xf32>, %M : index, %N: in
%K = constant 9 : index
// The buffer size can't be bound by a constant smaller than the original
// memref size; so the DMA buffer is the entire 100x100.
// CHECK: %0 = alloc() : memref<100x100xf32, 2>
// CHECK-NEXT: %1 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %arg0[%c0, %c0], %0[%c0, %c0], %1[%c0], %c10000 : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %1[%c0], %c10000 : memref<1xi32>
// CHECK: %{{.*}} = alloc() : memref<100x100xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<100x100xf32>, memref<100x100xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
affine.for %i = 0 to 100 {
affine.for %j = %M to %N {
%idy = affine.apply (d1) [s0] -> (d1 + s0)(%j)[%K]
@ -286,7 +286,7 @@ func @dma_unknown_size(%arg0: memref<?x?xf32>) {
affine.for %j = 0 to %N {
// If this loop nest isn't tiled, the access requires a non-constant DMA
// size -- not yet implemented.
// CHECK: %2 = affine.load %arg0[%i0, %i1] : memref<?x?xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
affine.load %arg0[%i, %j] : memref<? x ? x f32>
// expected-error@-6 {{DMA generation failed for one or more memref's in this block}}
}
@ -306,7 +306,7 @@ func @dma_memref_3d(%arg0: memref<1024x1024x1024xf32>) {
%idz = affine.apply (d0) -> (d0 mod 128)(%k)
// DMA with nested striding (or emulating with loop around strided DMA)
// not yet implemented.
// CHECK: %5 = affine.load %arg0[%2, %3, %4] : memref<1024x1024x1024xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}] : memref<1024x1024x1024xf32>
%v = affine.load %arg0[%idx, %idy, %idz] : memref<1024 x 1024 x 1024 x f32>
// expected-error@-10 {{DMA generation failed for one or more memref's in this block}}
}
@ -351,31 +351,31 @@ func @multi_load_store_union() {
}
return
}
// CHECK: %0 = alloc() : memref<512x512xf32>
// CHECK-NEXT: %1 = alloc() : memref<382x446xf32, 2>
// CHECK-NEXT: %2 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %0[%c2_1, %c2_2], %1[%c0, %c0], %2[%c0], %c170372_3, %c512_4, %c446_5 : memref<512x512xf32>, memref<382x446xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %2[%c0], %c170372_3 : memref<1xi32>
// CHECK-NEXT: %3 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.for %i0 = 0 to 256 {
// CHECK-NEXT: affine.for %i1 = 0 to 256 {
// CHECK-NEXT: %4 = affine.apply [[MAP_PLUS_64]](%i0)
// CHECK-NEXT: %5 = affine.apply [[MAP_PLUS_128]](%i1)
// CHECK-NEXT: %6 = affine.apply [[MAP_PLUS_2]](%i0)
// CHECK-NEXT: %7 = affine.apply [[MAP_PLUS_2]](%i1)
// CHECK-NEXT: %8 = affine.load %1[%i0, %i1 + 126] : memref<382x446xf32, 2>
// CHECK-NEXT: %9 = affine.load %1[%i0 + 62, %i1] : memref<382x446xf32, 2>
// CHECK-NEXT: %10 = affine.apply [[MAP_PLUS_128]](%i0)
// CHECK-NEXT: %11 = affine.apply [[MAP_PLUS_192]](%i1)
// CHECK-NEXT: affine.store %8, %1[%i0, %i1 + 190] : memref<382x446xf32, 2>
// CHECK-NEXT: affine.store %9, %1[%i0 + 126, %i1] : memref<382x446xf32, 2>
// CHECK: %{{.*}} = alloc() : memref<512x512xf32>
// CHECK-NEXT: %{{.*}} = alloc() : memref<382x446xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<512x512xf32>, memref<382x446xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 256 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 256 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_64]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_128]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_2]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_2]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}} + 126] : memref<382x446xf32, 2>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} + 62, %{{.*}}] : memref<382x446xf32, 2>
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_128]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_PLUS_192]](%{{.*}})
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}} + 190] : memref<382x446xf32, 2>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} + 126, %{{.*}}] : memref<382x446xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: affine.dma_start %1[%c0, %c0], %0[%c2, %c2_0], %3[%c0], %c170372, %c512, %c446 : memref<382x446xf32, 2>, memref<512x512xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %3[%c0], %c170372 : memref<1xi32>
// CHECK-NEXT: dealloc %3 : memref<1xi32>
// CHECK-NEXT: dealloc %2 : memref<1xi32>
// CHECK-NEXT: dealloc %1 : memref<382x446xf32, 2>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}, %{{.*}} : memref<382x446xf32, 2>, memref<512x512xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<382x446xf32, 2>
// CHECK-NEXT: return
// CHECK-NEXT:}
@ -396,35 +396,35 @@ func @dma_loop_straightline_interspersed() {
}
// There are three regions here - the 'load' preceding the loop, the loop
// itself, and the operations appearing after the loop.
// CHECK: %0 = alloc() : memref<256xf32>
// CHECK-NEXT: %1 = alloc() : memref<1xf32, 2>
// CHECK-NEXT: %2 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %0[%c0], %1[%c0], %2[%c0], %c1_1 : memref<256xf32>, memref<1xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %2[%c0], %c1_1 : memref<1xi32>
// CHECK-NEXT: %3 = affine.load %1[symbol(%c0_2)] : memref<1xf32, 2>
// CHECK-NEXT: dealloc %2 : memref<1xi32>
// CHECK-NEXT: dealloc %1 : memref<1xf32, 2>
// CHECK-NEXT: %4 = alloc() : memref<254xf32, 2>
// CHECK-NEXT: %5 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %0[%c1], %4[%c0], %5[%c0], %c254 : memref<256xf32>, memref<254xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %5[%c0], %c254 : memref<1xi32>
// CHECK-NEXT: affine.for %i0 = 1 to 255 {
// CHECK-NEXT: %6 = affine.load %4[%i0 - 1] : memref<254xf32, 2>
// CHECK: %{{.*}} = alloc() : memref<256xf32>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<1xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[symbol(%{{.*}})] : memref<1xf32, 2>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<254xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<254xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: affine.for %{{.*}} = 1 to 255 {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} - 1] : memref<254xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: dealloc %5 : memref<1xi32>
// CHECK-NEXT: dealloc %4 : memref<254xf32, 2>
// CHECK-NEXT: %7 = alloc() : memref<256xf32, 2>
// CHECK-NEXT: %8 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %0[%c0], %7[%c0], %8[%c0], %c256_0 : memref<256xf32>, memref<256xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %8[%c0], %c256_0 : memref<1xi32>
// CHECK-NEXT: %9 = alloc() : memref<1xi32>
// CHECK-NEXT: %10 = affine.load %7[symbol(%c255)] : memref<256xf32, 2>
// CHECK-NEXT: affine.store %10, %7[symbol(%c0_2)] : memref<256xf32, 2>
// CHECK-NEXT: affine.dma_start %7[%c0], %0[%c0], %9[%c0], %c256 : memref<256xf32, 2>, memref<256xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %9[%c0], %c256 : memref<1xi32>
// CHECK-NEXT: dealloc %9 : memref<1xi32>
// CHECK-NEXT: dealloc %8 : memref<1xi32>
// CHECK-NEXT: dealloc %7 : memref<256xf32, 2>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<254xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<256xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<256xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[symbol(%{{.*}})] : memref<256xf32, 2>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[symbol(%{{.*}})] : memref<256xf32, 2>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32, 2>, memref<256xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<1xi32>
// CHECK-NEXT: dealloc %{{.*}} : memref<256xf32, 2>
// CHECK-NEXT: return
// -----
@ -446,12 +446,12 @@ func @dma_mixed_loop_blocks() {
// CHECK-DAG: [[MEM:%[0-9]+]] = alloc() : memref<256x256xvector<8xf32>>
// CHECK-DAG: [[BUF:%[0-9]+]] = alloc() : memref<256x256xvector<8xf32>, 2>
// CHECK-DAG: [[TAG:%[0-9]+]] = alloc() : memref<1xi32>
// CHECK: affine.dma_start [[MEM]][%c0, %c0], [[BUF]][%c0, %c0], [[TAG]][%c0], %c65536 : memref<256x256xvector<8xf32>>, memref<256x256xvector<8xf32>, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait [[TAG]][%c0], %c65536 : memref<1xi32>
// CHECK-NEXT: affine.for %i0 = 0 to 256 {
// CHECK: %3 = affine.load [[BUF]][symbol(%c0_0), symbol(%c0_0)] : memref<256x256xvector<8xf32>, 2>
// CHECK: affine.for %i1 = 0 to 256 {
// CHECK-NEXT: %4 = affine.load [[BUF]][%i0, %i1] : memref<256x256xvector<8xf32>, 2>
// CHECK: affine.dma_start [[MEM]][%{{.*}}, %{{.*}}], [[BUF]][%{{.*}}, %{{.*}}], [[TAG]][%{{.*}}], %{{.*}} : memref<256x256xvector<8xf32>>, memref<256x256xvector<8xf32>, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait [[TAG]][%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 256 {
// CHECK: %{{.*}} = affine.load [[BUF]][symbol(%{{.*}}), symbol(%{{.*}})] : memref<256x256xvector<8xf32>, 2>
// CHECK: affine.for %{{.*}} = 0 to 256 {
// CHECK-NEXT: %{{.*}} = affine.load [[BUF]][%{{.*}}, %{{.*}}] : memref<256x256xvector<8xf32>, 2>
// -----
@ -467,14 +467,14 @@ func @relative_loop_bounds(%arg0: memref<1027xf32>) {
}
// CHECK: [[BUF:%[0-9]+]] = alloc() : memref<1027xf32, 2>
// CHECK-NEXT: [[MEM:%[0-9]+]] = alloc() : memref<1xi32>
// CHECK-NEXT: affine.for %i0 = 0 to 1024 {
// CHECK-NEXT: affine.for %i1 = {{#map[0-9]+}}(%i0) to {{#map[0-9]+}}(%i0) {
// CHECK-NEXT: %cst = constant 0.000000e+00 : f32
// CHECK-NEXT: affine.store %cst, [[BUF]][%i1] : memref<1027xf32, 2>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 {
// CHECK-NEXT: affine.for %{{.*}} = {{#map[0-9]+}}(%{{.*}}) to {{#map[0-9]+}}(%{{.*}}) {
// CHECK-NEXT: %{{.*}} = constant 0.000000e+00 : f32
// CHECK-NEXT: affine.store %{{.*}}, [[BUF]][%{{.*}}] : memref<1027xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: affine.dma_start [[BUF]][%c0], %arg0[%c0], [[MEM]][%c0], %c1027 : memref<1027xf32, 2>, memref<1027xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait [[MEM]][%c0], %c1027 : memref<1xi32>
// CHECK-NEXT: affine.dma_start [[BUF]][%{{.*}}], %{{.*}}[%{{.*}}], [[MEM]][%{{.*}}], %{{.*}} : memref<1027xf32, 2>, memref<1027xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait [[MEM]][%{{.*}}], %{{.*}} : memref<1xi32>
// -----
@ -496,20 +496,20 @@ func @test_read_write_region_union() {
return
}
// CHECK: %0 = alloc() : memref<256xf32>
// CHECK-NEXT: %1 = alloc() : memref<85xf32, 2>
// CHECK-NEXT: %2 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %0[%c25_0], %1[%c0], %2[%c0], %c85_1 : memref<256xf32>, memref<85xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %2[%c0], %c85_1 : memref<1xi32>
// CHECK-NEXT: %3 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: %4 = affine.apply [[MAP_READ_OFFSET]](%i0)
// CHECK-NEXT: %5 = affine.apply [[MAP_WRITE_OFFSET]](%i0)
// CHECK-NEXT: %6 = affine.load %1[%i0 + 75] : memref<85xf32, 2>
// CHECK-NEXT: affine.store %6, %1[%i0] : memref<85xf32, 2>
// CHECK: %{{.*}} = alloc() : memref<256xf32>
// CHECK-NEXT: %{{.*}} = alloc() : memref<85xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<256xf32>, memref<85xf32, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_READ_OFFSET]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_WRITE_OFFSET]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} + 75] : memref<85xf32, 2>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<85xf32, 2>
// CHECK-NEXT: }
// CHECK-NEXT: affine.dma_start %1[%c0], %0[%c25], %3[%c0], %c85 : memref<85xf32, 2>, memref<256xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %3[%c0], %c85 : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<85xf32, 2>, memref<256xf32>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// -----
@ -537,11 +537,11 @@ func @test_analysis_util(%arg0: memref<4x4x16x1xf32>, %arg1: memref<144x9xf32>,
}
return %arg1, %arg2 : memref<144x9xf32>, memref<2xf32>
}
// CHECK: affine.for %i0 = 0 to 9 step 3 {
// CHECK: affine.for %{{.*}} = 0 to 9 step 3 {
// CHECK: [[BUF:%[0-9]+]] = alloc() : memref<2xf32, 2>
// CHECK: affine.dma_start %arg2[%i0 floordiv 8], [[BUF]]
// CHECK: affine.dma_wait %6[%c0], %c2_0 : memref<1xi32>
// CHECK: affine.for %i1 =
// CHECK: affine.dma_start %{{.*}}[%{{.*}} floordiv 8], [[BUF]]
// CHECK: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// CHECK: affine.for %{{.*}} =
// ----
@ -566,10 +566,10 @@ func @test_memref_bounds(%arg0: memref<4x4x16x1xvector<8x128xf32>>, %arg1: memre
return %arg1, %arg2 : memref<144x9xvector<8x128xf32>>, memref<2xvector<8x128xf32>>
}
// CHECK: %0 = alloc() : memref<4x4x16x1xvector<8x128xf32>, 2>
// CHECK-NEXT: %1 = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %arg0[%c0, %c0, %c0, %c0], %0[%c0, %c0, %c0, %c0], %1[%c0], %c256 : memref<4x4x16x1xvector<8x128xf32>>, memref<4x4x16x1xvector<8x128xf32>, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %1[%c0], %c256 : memref<1xi32>
// CHECK: %{{.*}} = alloc() : memref<4x4x16x1xvector<8x128xf32>, 2>
// CHECK-NEXT: %{{.*}} = alloc() : memref<1xi32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}], %{{.*}}[%{{.*}}], %{{.*}} : memref<4x4x16x1xvector<8x128xf32>>, memref<4x4x16x1xvector<8x128xf32>, 2>, memref<1xi32>
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
// -----
@ -578,16 +578,16 @@ func @test_memref_bounds(%arg0: memref<4x4x16x1xvector<8x128xf32>>, %arg1: memre
// FAST-MEM-16KB-LABEL: func @load_store_same_memref
func @load_store_same_memref(%arg0: memref<256x1024xf32>) {
// FAST-MEM-16KB: affine.for %i0 = 0 to 256 step 4
// FAST-MEM-16KB: affine.for %{{.*}} = 0 to 256 step 4
affine.for %i0 = 0 to 256 step 4 {
// FAST-MEM-16KB: [[BUF:%[0-9]+]] = alloc() : memref<4x1024xf32, 2>
// FAST-MEM-16KB: affine.dma_start %arg0
// FAST-MEM-16KB: affine.dma_start %{{.*}}
// FAST-MEM-16KB-NEXT: affine.dma_wait
// FAST-MEM-16KB: affine.for %i1
// FAST-MEM-16KB: affine.for %{{.*}}
affine.for %i1 = 0 to 1024 step 4 {
// FAST-MEM-16KB: affine.for %i2
// FAST-MEM-16KB: affine.for %{{.*}}
affine.for %i2 = (d0) -> (d0)(%i0) to (d0) -> (d0 + 4)(%i0) {
// FAST-MEM-16KB: affine.for %i3
// FAST-MEM-16KB: affine.for %{{.*}}
affine.for %i3 = (d0) -> (d0)(%i1) to (d0) -> (d0 + 4)(%i1) {
%3 = affine.load %arg0[%i2, %i3] : memref<256x1024xf32>
%4 = mulf %3, %3 : f32
@ -634,21 +634,21 @@ func @simple_matmul(%arg0: memref<8x8xvector<64xf32>>, %arg1: memref<8x8xvector<
}
return %arg2 : memref<8x8xvector<64xf32>>
}
// FAST-MEM-16KB: affine.for %i0 = 0 to 8 step 4 {
// FAST-MEM-16KB: affine.for %i1 = 0 to 8 step 4 {
// FAST-MEM-16KB: affine.dma_start %arg2
// FAST-MEM-16KB: affine.for %{{.*}} = 0 to 8 step 4 {
// FAST-MEM-16KB: affine.for %{{.*}} = 0 to 8 step 4 {
// FAST-MEM-16KB: affine.dma_start %{{.*}}
// FAST-MEM-16KB: affine.dma_wait
// FAST-MEM-16KB: affine.for %i2 = 0 to 8 step 4 {
// FAST-MEM-16KB: affine.dma_start %arg0
// FAST-MEM-16KB: affine.for %{{.*}} = 0 to 8 step 4 {
// FAST-MEM-16KB: affine.dma_start %{{.*}}
// FAST-MEM-16KB: affine.dma_wait
// FAST-MEM-16KB: affine.dma_start %arg1
// FAST-MEM-16KB: affine.dma_start %{{.*}}
// FAST-MEM-16KB: affine.dma_wait
// FAST-MEM-16KB: affine.for %i3 = #map{{[0-9]+}}(%i0) to #map{{[0-9]+}}(%i0) {
// FAST-MEM-16KB-NEXT: affine.for %i4 = #map{{[0-9]+}}(%i1) to #map{{[0-9]+}}(%i1) {
// FAST-MEM-16KB-NEXT: affine.for %i5 = #map{{[0-9]+}}(%i2) to #map{{[0-9]+}}(%i2) {
// FAST-MEM-16KB: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to #map{{[0-9]+}}(%{{.*}}) {
// FAST-MEM-16KB-NEXT: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to #map{{[0-9]+}}(%{{.*}}) {
// FAST-MEM-16KB-NEXT: affine.for %{{.*}} = #map{{[0-9]+}}(%{{.*}}) to #map{{[0-9]+}}(%{{.*}}) {
// FAST-MEM-16KB: }
// FAST-MEM-16KB: }
// FAST-MEM-16KB: }
// FAST-MEM-16KB: }
// FAST-MEM-16KB: affine.dma_start %2[%c0, %c0], %arg2
// FAST-MEM-16KB: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}
// FAST-MEM-16KB: affine.dma_wait

964
mlir/test/Transforms/loop-fusion.mlir
View File

File diff suppressed because it is too large Load Diff

302
mlir/test/Transforms/loop-invariant-code-motion.mlir
View File

@ -5,10 +5,10 @@ func @nested_loops_both_having_invariant_code() {
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %arg0 = 0 to 10 {
%v0 = addf %cf7, %cf8 : f32
affine.for %i1 = 0 to 10 {
affine.store %v0, %m[%i0] : memref<10xf32>
affine.for %arg1 = 0 to 10 {
affine.store %v0, %m[%arg0] : memref<10xf32>
}
}
@ -16,8 +16,8 @@ func @nested_loops_both_having_invariant_code() {
// CHECK-NEXT: %cst = constant 7.000000e+00 : f32
// CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
// CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.store %1, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return
return
@ -29,15 +29,15 @@ func @nested_loops_both_having_invariant_code() {
func @store_affine_apply() -> memref<10xf32> {
%cf7 = constant 7.0 : f32
%m = alloc() : memref<10xf32>
affine.for %i0 = 0 to 10 {
%t0 = affine.apply (d1) -> (d1 + 1)(%i0)
affine.for %arg0 = 0 to 10 {
%t0 = affine.apply (d1) -> (d1 + 1)(%arg0)
affine.store %cf7, %m[%t0] : memref<10xf32>
}
return %m : memref<10xf32>
// CHECK: %cst = constant 7.000000e+00 : f32
// CHECK-NEXT: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: %1 = affine.apply #map3(%i0)
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: %1 = affine.apply #map3(%arg0)
// CHECK-NEXT: affine.store %cst, %0[%1] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return %0 : memref<10xf32>
@ -48,8 +48,8 @@ func @nested_loops_code_invariant_to_both() {
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
%v0 = addf %cf7, %cf8 : f32
}
}
@ -65,20 +65,20 @@ func @nested_loops_code_invariant_to_both() {
func @single_loop_nothing_invariant() {
%m1 = alloc() : memref<10xf32>
%m2 = alloc() : memref<10xf32>
affine.for %i0 = 0 to 10 {
%v0 = affine.load %m1[%i0] : memref<10xf32>
%v1 = affine.load %m2[%i0] : memref<10xf32>
affine.for %arg0 = 0 to 10 {
%v0 = affine.load %m1[%arg0] : memref<10xf32>
%v1 = affine.load %m2[%arg0] : memref<10xf32>
%v2 = addf %v0, %v1 : f32
affine.store %v2, %m1[%i0] : memref<10xf32>
affine.store %v2, %m1[%arg0] : memref<10xf32>
}
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %1 = alloc() : memref<10xf32>
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: %2 = affine.load %0[%i0] : memref<10xf32>
// CHECK-NEXT: %3 = affine.load %1[%i0] : memref<10xf32>
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: %2 = affine.load %0[%arg0] : memref<10xf32>
// CHECK-NEXT: %3 = affine.load %1[%arg0] : memref<10xf32>
// CHECK-NEXT: %4 = addf %2, %3 : f32
// CHECK-NEXT: affine.store %4, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.store %4, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return
return
@ -89,22 +89,22 @@ func @invariant_code_inside_affine_if() {
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
%t0 = affine.apply (d1) -> (d1 + 1)(%i0)
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %t0) {
affine.for %arg0 = 0 to 10 {
%t0 = affine.apply (d1) -> (d1 + 1)(%arg0)
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %t0) {
%cf9 = addf %cf8, %cf8 : f32
affine.store %cf9, %m[%i0] : memref<10xf32>
affine.store %cf9, %m[%arg0] : memref<10xf32>
}
}
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: %1 = affine.apply #map3(%i0)
// CHECK-NEXT: affine.if #set0(%i0, %1) {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: %1 = affine.apply #map3(%arg0)
// CHECK-NEXT: affine.if #set0(%arg0, %1) {
// CHECK-NEXT: %2 = addf %cst, %cst : f32
// CHECK-NEXT: affine.store %2, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.store %2, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -118,12 +118,12 @@ func @dependent_stores() {
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %arg0 = 0 to 10 {
%v0 = addf %cf7, %cf8 : f32
affine.for %i1 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
%v1 = addf %cf7, %cf7 : f32
affine.store %v1, %m[%i1] : memref<10xf32>
affine.store %v0, %m[%i0] : memref<10xf32>
affine.store %v1, %m[%arg1] : memref<10xf32>
affine.store %v0, %m[%arg0] : memref<10xf32>
}
}
@ -132,11 +132,11 @@ func @dependent_stores() {
// CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
// CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
// CHECK-NEXT: %2 = addf %cst, %cst : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: affine.store %2, %0[%i1] : memref<10xf32>
// CHECK-NEXT: affine.store %1, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: affine.store %2, %0[%arg1] : memref<10xf32>
// CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -148,12 +148,12 @@ func @independent_stores() {
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %arg0 = 0 to 10 {
%v0 = addf %cf7, %cf8 : f32
affine.for %i1 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
%v1 = addf %cf7, %cf7 : f32
affine.store %v0, %m[%i0] : memref<10xf32>
affine.store %v1, %m[%i1] : memref<10xf32>
affine.store %v0, %m[%arg0] : memref<10xf32>
affine.store %v1, %m[%arg1] : memref<10xf32>
}
}
@ -162,10 +162,10 @@ func @independent_stores() {
// CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
// CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
// CHECK-NEXT: %2 = addf %cst, %cst : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: affine.store %1, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.store %2, %0[%i1] : memref<10xf32>
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: affine.store %2, %0[%arg1] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -177,12 +177,12 @@ func @load_dependent_store() {
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %arg0 = 0 to 10 {
%v0 = addf %cf7, %cf8 : f32
affine.for %i1 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
%v1 = addf %cf7, %cf7 : f32
affine.store %v0, %m[%i1] : memref<10xf32>
%v2 = affine.load %m[%i0] : memref<10xf32>
affine.store %v0, %m[%arg1] : memref<10xf32>
%v2 = affine.load %m[%arg0] : memref<10xf32>
}
}
@ -191,10 +191,10 @@ func @load_dependent_store() {
// CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
// CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
// CHECK-NEXT: %2 = addf %cst, %cst : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: affine.store %1, %0[%i1] : memref<10xf32>
// CHECK-NEXT: %3 = affine.load %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
// CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -206,12 +206,12 @@ func @load_after_load() {
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %arg0 = 0 to 10 {
%v0 = addf %cf7, %cf8 : f32
affine.for %i1 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
%v1 = addf %cf7, %cf7 : f32
%v3 = affine.load %m[%i1] : memref<10xf32>
%v2 = affine.load %m[%i0] : memref<10xf32>
%v3 = affine.load %m[%arg1] : memref<10xf32>
%v2 = affine.load %m[%arg0] : memref<10xf32>
}
}
@ -220,10 +220,10 @@ func @load_after_load() {
// CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
// CHECK-NEXT: %1 = addf %cst, %cst_0 : f32
// CHECK-NEXT: %2 = addf %cst, %cst : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: %3 = affine.load %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: %4 = affine.load %0[%i1] : memref<10xf32>
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: %4 = affine.load %0[%arg1] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -233,11 +233,11 @@ func @load_after_load() {
func @invariant_affine_if() {
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
%cf9 = addf %cf8, %cf8 : f32
affine.store %cf9, %m[%i0] : memref<10xf32>
affine.store %cf9, %m[%arg0] : memref<10xf32>
}
}
@ -245,10 +245,10 @@ func @invariant_affine_if() {
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: %1 = addf %cst, %cst : f32
// CHECK-NEXT: affine.store %1, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -259,11 +259,11 @@ func @invariant_affine_if() {
func @invariant_affine_if2() {
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
%cf9 = addf %cf8, %cf8 : f32
affine.store %cf9, %m[%i1] : memref<10xf32>
affine.store %cf9, %m[%arg1] : memref<10xf32>
}
}
@ -271,11 +271,11 @@ func @invariant_affine_if2() {
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: %1 = addf %cst, %cst : f32
// CHECK-NEXT: affine.store %1, %0[%i1] : memref<10xf32>
// CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -287,13 +287,13 @@ func @invariant_affine_if2() {
func @invariant_affine_nested_if() {
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
%cf9 = addf %cf8, %cf8 : f32
affine.store %cf9, %m[%i0] : memref<10xf32>
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.store %cf9, %m[%i1] : memref<10xf32>
affine.store %cf9, %m[%arg0] : memref<10xf32>
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
affine.store %cf9, %m[%arg1] : memref<10xf32>
}
}
}
@ -301,13 +301,13 @@ func @invariant_affine_nested_if() {
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: %1 = addf %cst, %cst : f32
// CHECK-NEXT: affine.store %1, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.store %1, %0[%i1] : memref<10xf32>
// CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -320,15 +320,15 @@ func @invariant_affine_nested_if() {
func @invariant_affine_nested_if_else() {
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
%cf9 = addf %cf8, %cf8 : f32
affine.store %cf9, %m[%i0] : memref<10xf32>
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.store %cf9, %m[%i0] : memref<10xf32>
affine.store %cf9, %m[%arg0] : memref<10xf32>
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
affine.store %cf9, %m[%arg0] : memref<10xf32>
} else {
affine.store %cf9, %m[%i1] : memref<10xf32>
affine.store %cf9, %m[%arg1] : memref<10xf32>
}
}
}
@ -336,15 +336,15 @@ func @invariant_affine_nested_if_else() {
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: %1 = addf %cst, %cst : f32
// CHECK-NEXT: affine.store %1, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.store %1, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: } else {
// CHECK-NEXT: affine.store %1, %0[%i1] : memref<10xf32>
// CHECK-NEXT: affine.store %1, %0[%arg1] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -358,15 +358,15 @@ func @invariant_affine_nested_if_else2() {
%m = alloc() : memref<10xf32>
%m2 = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
%cf9 = addf %cf8, %cf8 : f32
%tload1 = affine.load %m[%i0] : memref<10xf32>
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.store %cf9, %m2[%i0] : memref<10xf32>
%tload1 = affine.load %m[%arg0] : memref<10xf32>
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
affine.store %cf9, %m2[%arg0] : memref<10xf32>
} else {
%tload2 = affine.load %m[%i0] : memref<10xf32>
%tload2 = affine.load %m[%arg0] : memref<10xf32>
}
}
}
@ -375,14 +375,14 @@ func @invariant_affine_nested_if_else2() {
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %1 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: %2 = addf %cst, %cst : f32
// CHECK-NEXT: %3 = affine.load %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.store %2, %1[%i0] : memref<10xf32>
// CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: affine.store %2, %1[%arg0] : memref<10xf32>
// CHECK-NEXT: } else {
// CHECK-NEXT: %4 = affine.load %0[%i0] : memref<10xf32>
// CHECK-NEXT: %4 = affine.load %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -395,13 +395,13 @@ func @invariant_affine_nested_if_else2() {
func @invariant_affine_nested_if2() {
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
%cf9 = addf %cf8, %cf8 : f32
%v1 = affine.load %m[%i0] : memref<10xf32>
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
%v2 = affine.load %m[%i0] : memref<10xf32>
%v1 = affine.load %m[%arg0] : memref<10xf32>
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
%v2 = affine.load %m[%arg0] : memref<10xf32>
}
}
}
@ -409,12 +409,12 @@ func @invariant_affine_nested_if2() {
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: %1 = addf %cst, %cst : f32
// CHECK-NEXT: %2 = affine.load %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: %3 = affine.load %0[%i0] : memref<10xf32>
// CHECK-NEXT: %2 = affine.load %0[%arg0] : memref<10xf32>
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: %3 = affine.load %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -426,13 +426,13 @@ func @invariant_affine_nested_if2() {
func @invariant_affine_for_inside_affine_if() {
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%i0, %i0) {
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
affine.if (d0, d1) : (d1 - d0 >= 0) (%arg0, %arg0) {
%cf9 = addf %cf8, %cf8 : f32
affine.store %cf9, %m[%i0] : memref<10xf32>
affine.for %i2 = 0 to 10 {
affine.store %cf9, %m[%i2] : memref<10xf32>
affine.store %cf9, %m[%arg0] : memref<10xf32>
affine.for %arg2 = 0 to 10 {
affine.store %cf9, %m[%arg2] : memref<10xf32>
}
}
}
@ -440,13 +440,13 @@ func @invariant_affine_for_inside_affine_if() {
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%i0, %i0) {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: affine.if #set0(%arg0, %arg0) {
// CHECK-NEXT: %1 = addf %cst, %cst : f32
// CHECK-NEXT: affine.store %1, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.for %i2 = 0 to 10 {
// CHECK-NEXT: affine.store %1, %0[%i2] : memref<10xf32>
// CHECK-NEXT: affine.store %1, %0[%arg0] : memref<10xf32>
// CHECK-NEXT: affine.for %arg2 = 0 to 10 {
// CHECK-NEXT: affine.store %1, %0[%arg2] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -460,18 +460,18 @@ func @invariant_affine_for_inside_affine_if() {
func @invariant_constant_and_load() {
%m = alloc() : memref<100xf32>
%m2 = alloc() : memref<100xf32>
affine.for %i0 = 0 to 5 {
affine.for %arg0 = 0 to 5 {
%c0 = constant 0 : index
%v = affine.load %m2[%c0] : memref<100xf32>
affine.store %v, %m[%i0] : memref<100xf32>
affine.store %v, %m[%arg0] : memref<100xf32>
}
// CHECK: %0 = alloc() : memref<100xf32>
// CHECK-NEXT: %1 = alloc() : memref<100xf32>
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %2 = affine.load %1[%c0] : memref<100xf32>
// CHECK-NEXT: affine.for %i0 = 0 to 5 {
// CHECK-NEXT: affine.store %2, %0[%i0] : memref<100xf32>
// CHECK-NEXT: affine.for %arg0 = 0 to 5 {
// CHECK-NEXT: affine.store %2, %0[%arg0] : memref<100xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -483,20 +483,20 @@ func @nested_load_store_same_memref() {
%m = alloc() : memref<10xf32>
%cst = constant 8.0 : f32
%c0 = constant 0 : index
affine.for %i0 = 0 to 10 {
affine.for %arg0 = 0 to 10 {
%v0 = affine.load %m[%c0] : memref<10xf32>
affine.for %i1 = 0 to 10 {
affine.store %cst, %m[%i1] : memref<10xf32>
affine.for %arg1 = 0 to 10 {
affine.store %cst, %m[%arg1] : memref<10xf32>
}
}
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: %1 = affine.load %0[%c0] : memref<10xf32>
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: affine.store %cst, %0[%i1] : memref<10xf32>
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
// CHECK-NEXT: affine.store %cst, %0[%arg1] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -509,19 +509,19 @@ func @nested_load_store_same_memref2() {
%m = alloc() : memref<10xf32>
%cst = constant 8.0 : f32
%c0 = constant 0 : index
affine.for %i0 = 0 to 10 {
affine.for %arg0 = 0 to 10 {
affine.store %cst, %m[%c0] : memref<10xf32>
affine.for %i1 = 0 to 10 {
%v0 = affine.load %m[%i0] : memref<10xf32>
affine.for %arg1 = 0 to 10 {
%v0 = affine.load %m[%arg0] : memref<10xf32>
}
}
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.store %cst, %0[%c0] : memref<10xf32>
// CHECK-NEXT: %1 = affine.load %0[%i0] : memref<10xf32>
// CHECK-NEXT: %1 = affine.load %0[%arg0] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: return

76
mlir/test/Transforms/loop-tiling.mlir
View File

@ -8,27 +8,27 @@
// CHECK-DAG: [[IDENTITY:#map[0-9]+]] = (d0) -> (d0)
// CHECK-LABEL: func @loop_tiling()
// CHECK-NEXT: affine.for %i0 = 0 to 256 step 32 {
// CHECK-NEXT: affine.for %i1 = 0 to 512 step 32 {
// CHECK-NEXT: affine.for %i2 = 0 to 1024 step 32 {
// CHECK-NEXT: affine.for %i3 = [[IDENTITY]](%i0) to [[MAP0]](%i0) {
// CHECK-NEXT: affine.for %i4 = [[IDENTITY]](%i1) to [[MAP0]](%i1) {
// CHECK-NEXT: affine.for %i5 = [[IDENTITY]](%i2) to [[MAP0]](%i2) {
// CHECK-NEXT: "foo"(%i3, %i4, %i5) : (index, index, index) -> ()
// CHECK-NEXT: affine.for %{{.*}} = 0 to 256 step 32 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 512 step 32 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 1024 step 32 {
// CHECK-NEXT: affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to [[MAP0]](%{{.*}}) {
// CHECK-NEXT: affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to [[MAP0]](%{{.*}}) {
// CHECK-NEXT: affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to [[MAP0]](%{{.*}}) {
// CHECK-NEXT: "foo"(%{{.*}}, %{{.*}}, %{{.*}}) : (index, index, index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: affine.for %i6 = 0 to 50 step 32 {
// CHECK-NEXT: affine.for %i7 = [[IDENTITY]](%i6) to min [[MAP1]](%i6) {
// CHECK-NEXT: "bar"(%i7, %i7) : (index, index) -> ()
// CHECK-NEXT: affine.for %{{.*}} = 0 to 50 step 32 {
// CHECK-NEXT: affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to min [[MAP1]](%{{.*}}) {
// CHECK-NEXT: "bar"(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: affine.for %i8 = 0 to 21 step 32 {
// CHECK-NEXT: affine.for %i9 = [[IDENTITY]](%i8) to 21 {
// CHECK-NEXT: "foobar"(%i9) : (index) -> ()
// CHECK-NEXT: affine.for %{{.*}} = 0 to 21 step 32 {
// CHECK-NEXT: affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to 21 {
// CHECK-NEXT: "foobar"(%{{.*}}) : (index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -62,16 +62,16 @@ func @loop_tiling() {
#lb = ()[s0] -> (0, s0)
#ub = ()[s0, s1] -> (s0, 4096 floordiv s1)
// CHECK-LABEL: func @loop_max_min_bound(%arg0: memref<?xi32>, %arg1: index, %arg2: index) {
// CHECK-LABEL: func @loop_max_min_bound(%{{.*}}: memref<?xi32>, %{{.*}}: index, %{{.*}}: index) {
func @loop_max_min_bound(%A : memref<? x i32>, %L : index, %U : index) {
%M = dim %A, 0 : memref<? x i32>
affine.for %iTT = max #lb()[%L] to min #ub()[%M, %U] {
%out = affine.apply (d0) -> (d0) (%iTT)
}
return
// CHECK: affine.for %i0 = max [[LB]]()[%arg1] to min [[UB]]()[%0, %arg2] step 32 {
// CHECK-NEXT: affine.for %i1 = [[IDENTITY]](%i0) to min [[UB_INTRA_TILE]](%i0)[%0, %arg2] {
// CHECK-NEXT: %1 = affine.apply [[IDENTITY]](%i1)
// CHECK: affine.for %{{.*}} = max [[LB]]()[%{{.*}}] to min [[UB]]()[%{{.*}}, %{{.*}}] step 32 {
// CHECK-NEXT: affine.for %{{.*}} = [[IDENTITY]](%{{.*}}) to min [[UB_INTRA_TILE]](%{{.*}})[%{{.*}}, %{{.*}}] {
// CHECK-NEXT: %{{.*}} = affine.apply [[IDENTITY]](%{{.*}})
// CHECK-NEXT: }
// CHECK-NEXT: }
}
@ -98,9 +98,9 @@ func @simple_matmul(%arg0: memref<256x256xvector<64xf32>>, %arg1: memref<256x256
}
return %arg2 : memref<256x256xvector<64xf32>>
}
// MODEL: affine.for %i0 = 0 to 256 step 4 {
// MODEL-NEXT: affine.for %i1 = 0 to 256 step 4 {
// MODEL-NEXT: affine.for %i2 = 0 to 250 step 5 {
// MODEL: affine.for %{{.*}} = 0 to 256 step 4 {
// MODEL-NEXT: affine.for %{{.*}} = 0 to 256 step 4 {
// MODEL-NEXT: affine.for %{{.*}} = 0 to 250 step 5 {
// -----
@ -126,19 +126,19 @@ func @tile_with_symbolic_loop_upper_bounds(%arg0: memref<?x?xf32>, %arg1: memref
return
}
// CHECK: %0 = dim %arg0, 0 : memref<?x?xf32>
// CHECK-NEXT: affine.for %i0 = 0 to %0 step 32 {
// CHECK-NEXT: affine.for %i1 = 0 to %0 step 32 {
// CHECK-NEXT: affine.for %i2 = #map3(%i0) to min [[UBMAP]](%i0)[%0] {
// CHECK-NEXT: affine.for %i3 = #map3(%i1) to min [[UBMAP]](%i1)[%0] {
// CHECK-NEXT: affine.store %cst, %arg2[%i2, %i3] : memref<?x?xf32>
// CHECK-NEXT: affine.for %i4 = 0 to %0 {
// CHECK-NEXT: %1 = affine.load %arg0[%i2, %i4] : memref<?x?xf32>
// CHECK-NEXT: %2 = affine.load %arg1[%i4, %i3] : memref<?x?xf32>
// CHECK-NEXT: %3 = mulf %1, %2 : f32
// CHECK-NEXT: %4 = affine.load %arg2[%i2, %i3] : memref<?x?xf32>
// CHECK-NEXT: %5 = addf %4, %3 : f32
// CHECK-NEXT: affine.store %5, %arg2[%i2, %i3] : memref<?x?xf32>
// CHECK: %{{.*}} = dim %{{.*}}, 0 : memref<?x?xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to %{{.*}} step 32 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to %{{.*}} step 32 {
// CHECK-NEXT: affine.for %{{.*}} = #map3(%{{.*}}) to min [[UBMAP]](%{{.*}})[%{{.*}}] {
// CHECK-NEXT: affine.for %{{.*}} = #map3(%{{.*}}) to min [[UBMAP]](%{{.*}})[%{{.*}}] {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to %{{.*}} {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<?x?xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -160,10 +160,10 @@ func @tile_with_loop_upper_bounds_in_two_symbols(%arg0: memref<?xf32>, %limit: i
return
}
// CHECK: %0 = dim %arg0, 0 : memref<?xf32>
// CHECK-NEXT: affine.for %i0 = 0 to [[MAP1]]()[%0, %arg1] step 32 {
// CHECK-NEXT: affine.for %i1 = [[MAP0]](%i0) to min [[UBMAP]](%i0)[%0, %arg1] {
// CHECK-NEXT: %1 = affine.load %arg0[%i1] : memref<?xf32>
// CHECK: %{{.*}} = dim %{{.*}}, 0 : memref<?xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to [[MAP1]]()[%{{.*}}, %{{.*}}] step 32 {
// CHECK-NEXT: affine.for %{{.*}} = [[MAP0]](%{{.*}}) to min [[UBMAP]](%{{.*}})[%{{.*}}, %{{.*}}] {
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<?xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
@ -180,5 +180,5 @@ func @trip_count_1(%arg0: memref<196608x1xf32>, %arg1: memref<196608x1xf32>)
return %arg1 : memref<196608x1xf32>
}
// CHECK: %0 = affine.load %arg0[%i2, %i3] : memref<196608x1xf32>
// CHECK: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<196608x1xf32>

630
mlir/test/Transforms/lower-affine.mlir
View File

@ -9,17 +9,17 @@ func @body(index) -> ()
// Simple loops are properly converted.
// CHECK-LABEL: func @simple_loop() {
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: br ^bb1(%c1 : index)
// CHECK-NEXT: ^bb1(%0: index): // 2 preds: ^bb0, ^bb2
// CHECK-NEXT: %1 = cmpi "slt", %0, %c42 : index
// CHECK-NEXT: cond_br %1, ^bb2, ^bb3
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb2
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb3
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: call @body(%0) : (index) -> ()
// CHECK-NEXT: %c1_0 = constant 1 : index
// CHECK-NEXT: %2 = addi %0, %c1_0 : index
// CHECK-NEXT: br ^bb1(%2 : index)
// CHECK-NEXT: call @body(%{{.*}}) : (index) -> ()
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb3: // pred: ^bb1
// CHECK-NEXT: return
// CHECK-NEXT: }
@ -37,30 +37,30 @@ func @body2(index, index) -> ()
func @post(index) -> ()
// CHECK-LABEL: func @imperfectly_nested_loops() {
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: br ^bb1(%c0 : index)
// CHECK-NEXT: ^bb1(%0: index): // 2 preds: ^bb0, ^bb5
// CHECK-NEXT: %1 = cmpi "slt", %0, %c42 : index
// CHECK-NEXT: cond_br %1, ^bb2, ^bb6
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb5
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb6
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: call @pre(%0) : (index) -> ()
// CHECK-NEXT: %c7 = constant 7 : index
// CHECK-NEXT: %c56 = constant 56 : index
// CHECK-NEXT: br ^bb3(%c7 : index)
// CHECK-NEXT: ^bb3(%2: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %3 = cmpi "slt", %2, %c56 : index
// CHECK-NEXT: cond_br %3, ^bb4, ^bb5
// CHECK-NEXT: call @pre(%{{.*}}) : (index) -> ()
// CHECK-NEXT: %{{.*}} = constant 7 : index
// CHECK-NEXT: %{{.*}} = constant 56 : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb3(%{{.*}}: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb4, ^bb5
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: call @body2(%0, %2) : (index, index) -> ()
// CHECK-NEXT: %c2 = constant 2 : index
// CHECK-NEXT: %4 = addi %2, %c2 : index
// CHECK-NEXT: br ^bb3(%4 : index)
// CHECK-NEXT: call @body2(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: %{{.*}} = constant 2 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb5: // pred: ^bb3
// CHECK-NEXT: call @post(%0) : (index) -> ()
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %5 = addi %0, %c1 : index
// CHECK-NEXT: br ^bb1(%5 : index)
// CHECK-NEXT: call @post(%{{.*}}) : (index) -> ()
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb6: // pred: ^bb1
// CHECK-NEXT: return
// CHECK-NEXT: }
@ -81,43 +81,43 @@ func @mid(index) -> ()
func @body3(index, index) -> ()
// CHECK-LABEL: func @more_imperfectly_nested_loops() {
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: br ^bb1(%c0 : index)
// CHECK-NEXT: ^bb1(%0: index): // 2 preds: ^bb0, ^bb8
// CHECK-NEXT: %1 = cmpi "slt", %0, %c42 : index
// CHECK-NEXT: cond_br %1, ^bb2, ^bb9
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb8
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb9
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: call @pre(%0) : (index) -> ()
// CHECK-NEXT: %c7 = constant 7 : index
// CHECK-NEXT: %c56 = constant 56 : index
// CHECK-NEXT: br ^bb3(%c7 : index)
// CHECK-NEXT: ^bb3(%2: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %3 = cmpi "slt", %2, %c56 : index
// CHECK-NEXT: cond_br %3, ^bb4, ^bb5
// CHECK-NEXT: call @pre(%{{.*}}) : (index) -> ()
// CHECK-NEXT: %{{.*}} = constant 7 : index
// CHECK-NEXT: %{{.*}} = constant 56 : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb3(%{{.*}}: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb4, ^bb5
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: call @body2(%0, %2) : (index, index) -> ()
// CHECK-NEXT: %c2 = constant 2 : index
// CHECK-NEXT: %4 = addi %2, %c2 : index
// CHECK-NEXT: br ^bb3(%4 : index)
// CHECK-NEXT: call @body2(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: %{{.*}} = constant 2 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb5: // pred: ^bb3
// CHECK-NEXT: call @mid(%0) : (index) -> ()
// CHECK-NEXT: %c18 = constant 18 : index
// CHECK-NEXT: %c37 = constant 37 : index
// CHECK-NEXT: br ^bb6(%c18 : index)
// CHECK-NEXT: ^bb6(%5: index): // 2 preds: ^bb5, ^bb7
// CHECK-NEXT: %6 = cmpi "slt", %5, %c37 : index
// CHECK-NEXT: cond_br %6, ^bb7, ^bb8
// CHECK-NEXT: call @mid(%{{.*}}) : (index) -> ()
// CHECK-NEXT: %{{.*}} = constant 18 : index
// CHECK-NEXT: %{{.*}} = constant 37 : index
// CHECK-NEXT: br ^bb6(%{{.*}} : index)
// CHECK-NEXT: ^bb6(%{{.*}}: index): // 2 preds: ^bb5, ^bb7
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb7, ^bb8
// CHECK-NEXT: ^bb7: // pred: ^bb6
// CHECK-NEXT: call @body3(%0, %5) : (index, index) -> ()
// CHECK-NEXT: %c3 = constant 3 : index
// CHECK-NEXT: %7 = addi %5, %c3 : index
// CHECK-NEXT: br ^bb6(%7 : index)
// CHECK-NEXT: call @body3(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: %{{.*}} = constant 3 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb6(%{{.*}} : index)
// CHECK-NEXT: ^bb8: // pred: ^bb6
// CHECK-NEXT: call @post(%0) : (index) -> ()
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %8 = addi %0, %c1 : index
// CHECK-NEXT: br ^bb1(%8 : index)
// CHECK-NEXT: call @post(%{{.*}}) : (index) -> ()
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb9: // pred: ^bb1
// CHECK-NEXT: return
// CHECK-NEXT: }
@ -136,27 +136,27 @@ func @more_imperfectly_nested_loops() {
return
}
// CHECK-LABEL: func @affine_apply_loops_shorthand(%arg0: index) {
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: br ^bb1(%c0 : index)
// CHECK-NEXT: ^bb1(%0: index): // 2 preds: ^bb0, ^bb5
// CHECK-NEXT: %1 = cmpi "slt", %0, %arg0 : index
// CHECK-NEXT: cond_br %1, ^bb2, ^bb6
// CHECK-LABEL: func @affine_apply_loops_shorthand(%{{.*}}: index) {
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%{{.*}}: index): // 2 preds: ^bb0, ^bb5
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb6
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: br ^bb3(%0 : index)
// CHECK-NEXT: ^bb3(%2: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %3 = cmpi "slt", %2, %c42 : index
// CHECK-NEXT: cond_br %3, ^bb4, ^bb5
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb3(%{{.*}}: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb4, ^bb5
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: call @body2(%0, %2) : (index, index) -> ()
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %4 = addi %2, %c1 : index
// CHECK-NEXT: br ^bb3(%4 : index)
// CHECK-NEXT: call @body2(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb5: // pred: ^bb3
// CHECK-NEXT: %c1_0 = constant 1 : index
// CHECK-NEXT: %5 = addi %0, %c1_0 : index
// CHECK-NEXT: br ^bb1(%5 : index)
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb6: // pred: ^bb1
// CHECK-NEXT: return
// CHECK-NEXT: }
@ -177,16 +177,16 @@ func @get_idx() -> (index)
#set2 = (d0) : (d0 - 10 >= 0)
// CHECK-LABEL: func @if_only() {
// CHECK-NEXT: %0 = call @get_idx() : () -> index
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c-1 = constant -1 : index
// CHECK-NEXT: %1 = muli %0, %c-1 : index
// CHECK-NEXT: %c20 = constant 20 : index
// CHECK-NEXT: %2 = addi %1, %c20 : index
// CHECK-NEXT: %3 = cmpi "sge", %2, %c0 : index
// CHECK-NEXT: cond_br %3, [[thenBB:\^bb[0-9]+]], [[endBB:\^bb[0-9]+]]
// CHECK-NEXT: %{{.*}} = call @get_idx() : () -> index
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}}-1 : index
// CHECK-NEXT: %{{.*}} = constant 20 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[thenBB:\^bb[0-9]+]], [[endBB:\^bb[0-9]+]]
// CHECK-NEXT: [[thenBB]]:
// CHECK-NEXT: call @body(%0) : (index) -> ()
// CHECK-NEXT: call @body(%{{.*}}) : (index) -> ()
// CHECK-NEXT: br [[endBB]]
// CHECK-NEXT: [[endBB]]:
// CHECK-NEXT: return
@ -200,19 +200,19 @@ func @if_only() {
}
// CHECK-LABEL: func @if_else() {
// CHECK-NEXT: %0 = call @get_idx() : () -> index
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c-1 = constant -1 : index
// CHECK-NEXT: %1 = muli %0, %c-1 : index
// CHECK-NEXT: %c20 = constant 20 : index
// CHECK-NEXT: %2 = addi %1, %c20 : index
// CHECK-NEXT: %3 = cmpi "sge", %2, %c0 : index
// CHECK-NEXT: cond_br %3, [[thenBB:\^bb[0-9]+]], [[elseBB:\^bb[0-9]+]]
// CHECK-NEXT: %{{.*}} = call @get_idx() : () -> index
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}}-1 : index
// CHECK-NEXT: %{{.*}} = constant 20 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[thenBB:\^bb[0-9]+]], [[elseBB:\^bb[0-9]+]]
// CHECK-NEXT: [[thenBB]]:
// CHECK-NEXT: call @body(%0) : (index) -> ()
// CHECK-NEXT: call @body(%{{.*}}) : (index) -> ()
// CHECK-NEXT: br [[endBB:\^bb[0-9]+]]
// CHECK-NEXT: [[elseBB]]:
// CHECK-NEXT: call @mid(%0) : (index) -> ()
// CHECK-NEXT: call @mid(%{{.*}}) : (index) -> ()
// CHECK-NEXT: br [[endBB]]
// CHECK-NEXT: [[endBB]]:
// CHECK-NEXT: return
@ -228,33 +228,33 @@ func @if_else() {
}
// CHECK-LABEL: func @nested_ifs() {
// CHECK-NEXT: %0 = call @get_idx() : () -> index
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c-1 = constant -1 : index
// CHECK-NEXT: %1 = muli %0, %c-1 : index
// CHECK-NEXT: %c20 = constant 20 : index
// CHECK-NEXT: %2 = addi %1, %c20 : index
// CHECK-NEXT: %3 = cmpi "sge", %2, %c0 : index
// CHECK-NEXT: cond_br %3, ^bb1, ^bb4
// CHECK-NEXT: %{{.*}} = call @get_idx() : () -> index
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}}-1 : index
// CHECK-NEXT: %{{.*}} = constant 20 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb1, ^bb4
// CHECK-NEXT: ^bb1: // pred: ^bb0
// CHECK-NEXT: %c0_0 = constant 0 : index
// CHECK-NEXT: %c-10 = constant -10 : index
// CHECK-NEXT: %4 = addi %0, %c-10 : index
// CHECK-NEXT: %5 = cmpi "sge", %4, %c0_0 : index
// CHECK-NEXT: cond_br %5, ^bb2, ^bb3
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-10 = constant -10 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}}-10 : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb2, ^bb3
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: call @body(%0) : (index) -> ()
// CHECK-NEXT: call @body(%{{.*}}) : (index) -> ()
// CHECK-NEXT: br ^bb3
// CHECK-NEXT: ^bb3: // 2 preds: ^bb1, ^bb2
// CHECK-NEXT: br ^bb7
// CHECK-NEXT: ^bb4: // pred: ^bb0
// CHECK-NEXT: %c0_1 = constant 0 : index
// CHECK-NEXT: %c-10_2 = constant -10 : index
// CHECK-NEXT: %6 = addi %0, %c-10_2 : index
// CHECK-NEXT: %7 = cmpi "sge", %6, %c0_1 : index
// CHECK-NEXT: cond_br %7, ^bb5, ^bb6
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-10_2 = constant -10 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}}-10_2 : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb5, ^bb6
// CHECK-NEXT: ^bb5: // pred: ^bb4
// CHECK-NEXT: call @mid(%0) : (index) -> ()
// CHECK-NEXT: call @mid(%{{.*}}) : (index) -> ()
// CHECK-NEXT: br ^bb6
// CHECK-NEXT: ^bb6: // 2 preds: ^bb4, ^bb5
// CHECK-NEXT: br ^bb7
@ -277,41 +277,41 @@ func @nested_ifs() {
#setN = (d0)[N,M,K,L] : (N - d0 + 1 >= 0, N - 1 >= 0, M - 1 >= 0, K - 1 >= 0, L - 42 == 0)
// CHECK-LABEL: func @multi_cond(%arg0: index, %arg1: index, %arg2: index, %arg3: index) {
// CHECK-NEXT: %0 = call @get_idx() : () -> index
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c-1 = constant -1 : index
// CHECK-NEXT: %1 = muli %0, %c-1 : index
// CHECK-NEXT: %2 = addi %1, %arg0 : index
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %3 = addi %2, %c1 : index
// CHECK-NEXT: %4 = cmpi "sge", %3, %c0 : index
// CHECK-NEXT: cond_br %4, [[cond2BB:\^bb[0-9]+]], [[elseBB:\^bb[0-9]+]]
// CHECK-LABEL: func @multi_cond(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
// CHECK-NEXT: %{{.*}} = call @get_idx() : () -> index
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}}-1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[cond2BB:\^bb[0-9]+]], [[elseBB:\^bb[0-9]+]]
// CHECK-NEXT: [[cond2BB]]:
// CHECK-NEXT: %c-1_0 = constant -1 : index
// CHECK-NEXT: %5 = addi %arg0, %c-1_0 : index
// CHECK-NEXT: %6 = cmpi "sge", %5, %c0 : index
// CHECK-NEXT: cond_br %6, [[cond3BB:\^bb[0-9]+]], [[elseBB]]
// CHECK-NEXT: %{{.*}}-1_0 = constant -1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}}-1_0 : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[cond3BB:\^bb[0-9]+]], [[elseBB]]
// CHECK-NEXT: [[cond3BB]]:
// CHECK-NEXT: %c-1_1 = constant -1 : index
// CHECK-NEXT: %7 = addi %arg1, %c-1_1 : index
// CHECK-NEXT: %8 = cmpi "sge", %7, %c0 : index
// CHECK-NEXT: cond_br %8, [[cond4BB:\^bb[0-9]+]], [[elseBB]]
// CHECK-NEXT: %{{.*}}-1_1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}}-1_1 : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[cond4BB:\^bb[0-9]+]], [[elseBB]]
// CHECK-NEXT: [[cond4BB]]:
// CHECK-NEXT: %c-1_2 = constant -1 : index
// CHECK-NEXT: %9 = addi %arg2, %c-1_2 : index
// CHECK-NEXT: %10 = cmpi "sge", %9, %c0 : index
// CHECK-NEXT: cond_br %10, [[cond5BB:\^bb[0-9]+]], [[elseBB]]
// CHECK-NEXT: %{{.*}}-1_2 = constant -1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}}-1_2 : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[cond5BB:\^bb[0-9]+]], [[elseBB]]
// CHECK-NEXT: [[cond5BB]]:
// CHECK-NEXT: %c-42 = constant -42 : index
// CHECK-NEXT: %11 = addi %arg3, %c-42 : index
// CHECK-NEXT: %12 = cmpi "eq", %11, %c0 : index
// CHECK-NEXT: cond_br %12, [[thenBB:\^bb[0-9]+]], [[elseBB]]
// CHECK-NEXT: %{{.*}}-42 = constant -42 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}}-42 : index
// CHECK-NEXT: %{{.*}} = cmpi "eq", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[thenBB:\^bb[0-9]+]], [[elseBB]]
// CHECK-NEXT: [[thenBB]]:
// CHECK-NEXT: call @body(%0) : (index) -> ()
// CHECK-NEXT: call @body(%{{.*}}) : (index) -> ()
// CHECK-NEXT: br [[endBB:\^bb[0-9]+]]
// CHECK-NEXT: [[elseBB]]:
// CHECK-NEXT: call @mid(%0) : (index) -> ()
// CHECK-NEXT: call @mid(%{{.*}}) : (index) -> ()
// CHECK-NEXT: br [[endBB]]
// CHECK-NEXT: [[endBB]]:
// CHECK-NEXT: return
@ -328,35 +328,35 @@ func @multi_cond(%N : index, %M : index, %K : index, %L : index) {
// CHECK-LABEL: func @if_for() {
func @if_for() {
// CHECK-NEXT: %0 = call @get_idx() : () -> index
// CHECK-NEXT: %{{.*}} = call @get_idx() : () -> index
%i = call @get_idx() : () -> (index)
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c-1 = constant -1 : index
// CHECK-NEXT: %1 = muli %0, %c-1 : index
// CHECK-NEXT: %c20 = constant 20 : index
// CHECK-NEXT: %2 = addi %1, %c20 : index
// CHECK-NEXT: %3 = cmpi "sge", %2, %c0 : index
// CHECK-NEXT: cond_br %3, [[midLoopInitBB:\^bb[0-9]+]], [[outerEndBB:\^bb[0-9]+]]
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}}-1 : index
// CHECK-NEXT: %{{.*}} = constant 20 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[midLoopInitBB:\^bb[0-9]+]], [[outerEndBB:\^bb[0-9]+]]
// CHECK-NEXT: [[midLoopInitBB]]:
// CHECK-NEXT: %c0_0 = constant 0 : index
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: br [[midLoopCondBB:\^bb[0-9]+]](%c0_0 : index)
// CHECK-NEXT: [[midLoopCondBB]](%4: index):
// CHECK-NEXT: %5 = cmpi "slt", %4, %c42 : index
// CHECK-NEXT: cond_br %5, [[midLoopBodyBB:\^bb[0-9]+]], [[outerEndBB:\^bb[0-9]+]]
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: br [[midLoopCondBB:\^bb[0-9]+]](%{{.*}} : index)
// CHECK-NEXT: [[midLoopCondBB]](%{{.*}}: index):
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[midLoopBodyBB:\^bb[0-9]+]], [[outerEndBB:\^bb[0-9]+]]
// CHECK-NEXT: [[midLoopBodyBB]]:
// CHECK-NEXT: %c0_1 = constant 0 : index
// CHECK-NEXT: %c-10 = constant -10 : index
// CHECK-NEXT: %6 = addi %4, %c-10 : index
// CHECK-NEXT: %7 = cmpi "sge", %6, %c0_1 : index
// CHECK-NEXT: cond_br %7, [[innerThenBB:\^bb[0-9]+]], [[innerEndBB:\^bb[0-9]+]]
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-10 = constant -10 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}}-10 : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[innerThenBB:\^bb[0-9]+]], [[innerEndBB:\^bb[0-9]+]]
// CHECK-NEXT: [[innerThenBB:\^bb[0-9]+]]:
// CHECK-NEXT: call @body2(%0, %4) : (index, index) -> ()
// CHECK-NEXT: call @body2(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: br [[innerEndBB]]
// CHECK-NEXT: [[innerEndBB]]:
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %8 = addi %4, %c1 : index
// CHECK-NEXT: br [[midLoopCondBB]](%8 : index)
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br [[midLoopCondBB]](%{{.*}} : index)
// CHECK-NEXT: [[outerEndBB]]:
// CHECK-NEXT: br [[outerLoopInit:\^bb[0-9]+]]
affine.if #set1(%i) {
@ -367,36 +367,36 @@ func @if_for() {
}
}
// CHECK-NEXT: [[outerLoopInit]]:
// CHECK-NEXT: %c0_2 = constant 0 : index
// CHECK-NEXT: %c42_3 = constant 42 : index
// CHECK-NEXT: br [[outerLoopCond:\^bb[0-9]+]](%c0_2 : index)
// CHECK-NEXT: [[outerLoopCond]](%9: index):
// CHECK-NEXT: %10 = cmpi "slt", %9, %c42_3 : index
// CHECK-NEXT: cond_br %10, [[outerLoopBody:\^bb[0-9]+]], [[outerLoopEnd:\^bb[0-9]+]]
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: br [[outerLoopCond:\^bb[0-9]+]](%{{.*}} : index)
// CHECK-NEXT: [[outerLoopCond]](%{{.*}}: index):
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[outerLoopBody:\^bb[0-9]+]], [[outerLoopEnd:\^bb[0-9]+]]
// CHECK-NEXT: [[outerLoopBody]]:
// CHECK-NEXT: %c0_4 = constant 0 : index
// CHECK-NEXT: %c-10_5 = constant -10 : index
// CHECK-NEXT: %11 = addi %9, %c-10_5 : index
// CHECK-NEXT: %12 = cmpi "sge", %11, %c0_4 : index
// CHECK-NEXT: cond_br %12, [[innerLoopInitBB:\^bb[0-9]+]], [[midEndBB:\^bb[0-9]+]]
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-10_5 = constant -10 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}}-10_5 : index
// CHECK-NEXT: %{{.*}} = cmpi "sge", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[innerLoopInitBB:\^bb[0-9]+]], [[midEndBB:\^bb[0-9]+]]
// CHECK-NEXT: [[innerLoopInitBB:\^bb[0-9]+]]:
// CHECK-NEXT: %c0_6 = constant 0 : index
// CHECK-NEXT: %c42_7 = constant 42 : index
// CHECK-NEXT: br [[innerLoopCondBB:\^bb[0-9]+]](%c0_6 : index)
// CHECK-NEXT: [[innerLoopCondBB]](%13: index):
// CHECK-NEXT: %14 = cmpi "slt", %13, %c42_7 : index
// CHECK-NEXT: cond_br %14, [[innerLoopBodyBB:\^bb[0-9]+]], [[innerLoopEndBB:\^bb[0-9]+]]
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: br [[innerLoopCondBB:\^bb[0-9]+]](%{{.*}} : index)
// CHECK-NEXT: [[innerLoopCondBB]](%{{.*}}: index):
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, [[innerLoopBodyBB:\^bb[0-9]+]], [[innerLoopEndBB:\^bb[0-9]+]]
// CHECK-NEXT: [[innerLoopBodyBB]]:
// CHECK-NEXT: call @body3(%9, %13) : (index, index) -> ()
// CHECK-NEXT: %c1_8 = constant 1 : index
// CHECK-NEXT: %15 = addi %13, %c1_8 : index
// CHECK-NEXT: br [[innerLoopCondBB]](%15 : index)
// CHECK-NEXT: call @body3(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br [[innerLoopCondBB]](%{{.*}} : index)
// CHECK-NEXT: [[innerLoopEndBB]]:
// CHECK-NEXT: br [[midEndBB]]
// CHECK-NEXT: [[midEndBB]]:
// CHECK-NEXT: %c1_9 = constant 1 : index
// CHECK-NEXT: %16 = addi %9, %c1_9 : index
// CHECK-NEXT: br [[outerLoopCond]](%16 : index)
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br [[outerLoopCond]](%{{.*}} : index)
affine.for %k = 0 to 42 {
affine.if #set2(%k) {
affine.for %l = 0 to 42 {
@ -412,36 +412,36 @@ func @if_for() {
#lbMultiMap = (d0)[s0] -> (d0, s0 - d0)
#ubMultiMap = (d0)[s0] -> (s0, d0 + 10)
// CHECK-LABEL: func @loop_min_max(%arg0: index) {
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: br ^bb1(%c0 : index)
// CHECK-LABEL: func @loop_min_max(%{{.*}}: index) {
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%{{[0-9]+}}: index): // 2 preds: ^bb0, ^bb5
// CHECK-NEXT: %1 = cmpi "slt", %0, %c42 : index
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{[0-9]+}}, ^bb2, ^bb6
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: %c-1 = constant -1 : index
// CHECK-NEXT: %2 = muli %0, %c-1 : index
// CHECK-NEXT: %3 = addi %2, %arg0 : index
// CHECK-NEXT: %4 = cmpi "sgt", %0, %3 : index
// CHECK-NEXT: %5 = select %4, %0, %3 : index
// CHECK-NEXT: %c10 = constant 10 : index
// CHECK-NEXT: %6 = addi %0, %c10 : index
// CHECK-NEXT: %7 = cmpi "slt", %arg0, %6 : index
// CHECK-NEXT: %8 = select %7, %arg0, %6 : index
// CHECK-NEXT: br ^bb3(%5 : index)
// CHECK-NEXT: ^bb3(%9: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %10 = cmpi "slt", %9, %8 : index
// CHECK-NEXT: cond_br %10, ^bb4, ^bb5
// CHECK-NEXT: %{{.*}}-1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}}-1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "sgt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 10 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb3(%{{.*}}: index): // 2 preds: ^bb2, ^bb4
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: cond_br %{{.*}}, ^bb4, ^bb5
// CHECK-NEXT: ^bb4: // pred: ^bb3
// CHECK-NEXT: call @body2(%0, %9) : (index, index) -> ()
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %11 = addi %9, %c1 : index
// CHECK-NEXT: br ^bb3(%11 : index)
// CHECK-NEXT: call @body2(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb3(%{{.*}} : index)
// CHECK-NEXT: ^bb5: // pred: ^bb3
// CHECK-NEXT: %c1_0 = constant 1 : index
// CHECK-NEXT: %12 = addi %0, %c1_0 : index
// CHECK-NEXT: br ^bb1(%12 : index)
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb6: // pred: ^bb1
// CHECK-NEXT: return
// CHECK-NEXT: }
@ -459,28 +459,28 @@ func @loop_min_max(%N : index) {
// Check that the "min" (cmpi "slt" + select) reduction sequence is emitted
// correctly for a an affine map with 7 results.
// CHECK-LABEL: func @min_reduction_tree(%arg0: index) {
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %[[c01:.+]] = cmpi "slt", %arg0, %arg0 : index
// CHECK-NEXT: %[[r01:.+]] = select %[[c01]], %arg0, %arg0 : index
// CHECK-NEXT: %[[c012:.+]] = cmpi "slt", %[[r01]], %arg0 : index
// CHECK-NEXT: %[[r012:.+]] = select %[[c012]], %[[r01]], %arg0 : index
// CHECK-NEXT: %[[c0123:.+]] = cmpi "slt", %[[r012]], %arg0 : index
// CHECK-NEXT: %[[r0123:.+]] = select %[[c0123]], %[[r012]], %arg0 : index
// CHECK-NEXT: %[[c01234:.+]] = cmpi "slt", %[[r0123]], %arg0 : index
// CHECK-NEXT: %[[r01234:.+]] = select %[[c01234]], %[[r0123]], %arg0 : index
// CHECK-NEXT: %[[c012345:.+]] = cmpi "slt", %[[r01234]], %arg0 : index
// CHECK-NEXT: %[[r012345:.+]] = select %[[c012345]], %[[r01234]], %arg0 : index
// CHECK-NEXT: %[[c0123456:.+]] = cmpi "slt", %[[r012345]], %arg0 : index
// CHECK-NEXT: %[[r0123456:.+]] = select %[[c0123456]], %[[r012345]], %arg0 : index
// CHECK-NEXT: br ^bb1(%c0 : index)
// CHECK-LABEL: func @min_reduction_tree(%{{.*}}: index) {
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %[[c01:.+]] = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %[[r01:.+]] = select %[[c01]], %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %[[c012:.+]] = cmpi "slt", %[[r01]], %{{.*}} : index
// CHECK-NEXT: %[[r012:.+]] = select %[[c012]], %[[r01]], %{{.*}} : index
// CHECK-NEXT: %[[c0123:.+]] = cmpi "slt", %[[r012]], %{{.*}} : index
// CHECK-NEXT: %[[r0123:.+]] = select %[[c0123]], %[[r012]], %{{.*}} : index
// CHECK-NEXT: %[[c01234:.+]] = cmpi "slt", %[[r0123]], %{{.*}} : index
// CHECK-NEXT: %[[r01234:.+]] = select %[[c01234]], %[[r0123]], %{{.*}} : index
// CHECK-NEXT: %[[c012345:.+]] = cmpi "slt", %[[r01234]], %{{.*}} : index
// CHECK-NEXT: %[[r012345:.+]] = select %[[c012345]], %[[r01234]], %{{.*}} : index
// CHECK-NEXT: %[[c0123456:.+]] = cmpi "slt", %[[r012345]], %{{.*}} : index
// CHECK-NEXT: %[[r0123456:.+]] = select %[[c0123456]], %[[r012345]], %{{.*}} : index
// CHECK-NEXT: br ^bb1(%{{.*}} : index)
// CHECK-NEXT: ^bb1(%{{[0-9]+}}: index): // 2 preds: ^bb0, ^bb2
// CHECK-NEXT: %{{[0-9]+}} = cmpi "slt", %{{[0-9]+}}, %[[r0123456]] : index
// CHECK-NEXT: cond_br %{{[0-9]+}}, ^bb2, ^bb3
// CHECK-NEXT: ^bb2: // pred: ^bb1
// CHECK-NEXT: call @body(%{{[0-9]+}}) : (index) -> ()
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %14 = addi %12, %c1 : index
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: br ^bb1(%{{[0-9]+}} : index)
// CHECK-NEXT: ^bb3: // pred: ^bb1
// CHECK-NEXT: return
@ -505,29 +505,29 @@ func @min_reduction_tree(%v : index) {
// CHECK-LABEL: func @affine_applies()
func @affine_applies() {
^bb0:
// CHECK: %c0 = constant 0 : index
// CHECK: %{{.*}} = constant 0 : index
%zero = affine.apply #map0()
// Identity maps are just discarded.
// CHECK-NEXT: %c101 = constant 101 : index
// CHECK-NEXT: %{{.*}} = constant 101 : index
%101 = constant 101 : index
%symbZero = affine.apply #map1()[%zero]
// CHECK-NEXT: %c102 = constant 102 : index
// CHECK-NEXT: %{{.*}} = constant 102 : index
%102 = constant 102 : index
%copy = affine.apply #map2(%zero)
// CHECK-NEXT: %0 = addi %c0, %c0 : index
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %1 = addi %0, %c1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
%one = affine.apply #map3(%symbZero)[%zero]
// CHECK-NEXT: %c103 = constant 103 : index
// CHECK-NEXT: %c104 = constant 104 : index
// CHECK-NEXT: %c105 = constant 105 : index
// CHECK-NEXT: %c106 = constant 106 : index
// CHECK-NEXT: %c107 = constant 107 : index
// CHECK-NEXT: %c108 = constant 108 : index
// CHECK-NEXT: %c109 = constant 109 : index
// CHECK-NEXT: %{{.*}} = constant 103 : index
// CHECK-NEXT: %{{.*}} = constant 104 : index
// CHECK-NEXT: %{{.*}} = constant 105 : index
// CHECK-NEXT: %{{.*}} = constant 106 : index
// CHECK-NEXT: %{{.*}} = constant 107 : index
// CHECK-NEXT: %{{.*}} = constant 108 : index
// CHECK-NEXT: %{{.*}} = constant 109 : index
%103 = constant 103 : index
%104 = constant 104 : index
%105 = constant 105 : index
@ -535,32 +535,32 @@ func @affine_applies() {
%107 = constant 107 : index
%108 = constant 108 : index
%109 = constant 109 : index
// CHECK-NEXT: %c2 = constant 2 : index
// CHECK-NEXT: %2 = muli %c104, %c2 : index
// CHECK-NEXT: %3 = addi %c103, %2 : index
// CHECK-NEXT: %c3 = constant 3 : index
// CHECK-NEXT: %4 = muli %c105, %c3 : index
// CHECK-NEXT: %5 = addi %3, %4 : index
// CHECK-NEXT: %c4 = constant 4 : index
// CHECK-NEXT: %6 = muli %c106, %c4 : index
// CHECK-NEXT: %7 = addi %5, %6 : index
// CHECK-NEXT: %c5 = constant 5 : index
// CHECK-NEXT: %8 = muli %c107, %c5 : index
// CHECK-NEXT: %9 = addi %7, %8 : index
// CHECK-NEXT: %c6 = constant 6 : index
// CHECK-NEXT: %10 = muli %c108, %c6 : index
// CHECK-NEXT: %11 = addi %9, %10 : index
// CHECK-NEXT: %c7 = constant 7 : index
// CHECK-NEXT: %12 = muli %c109, %c7 : index
// CHECK-NEXT: %13 = addi %11, %12 : index
// CHECK-NEXT: %{{.*}} = constant 2 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 3 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 4 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 5 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 6 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 7 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
%four = affine.apply #map4(%103,%104,%105,%106)[%107,%108,%109]
return
}
// CHECK-LABEL: func @args_ret_affine_apply(%arg0: index, %arg1: index)
// CHECK-LABEL: func @args_ret_affine_apply(%{{.*}}: index, %{{.*}}: index)
func @args_ret_affine_apply(index, index) -> (index, index) {
^bb0(%0 : index, %1 : index):
// CHECK-NEXT: return %arg0, %arg1 : index, index
// CHECK-NEXT: return %{{.*}}, %{{.*}} : index, index
%00 = affine.apply #map2 (%0)
%11 = affine.apply #map1 ()[%1]
return %00, %11 : index, index
@ -582,12 +582,12 @@ func @args_ret_affine_apply(index, index) -> (index, index) {
// --------------------------------------------------------------------------//
// CHECK-LABEL: func @affine_apply_mod
func @affine_apply_mod(%arg0 : index) -> (index) {
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: %0 = remis %arg0, %c42 : index
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %1 = cmpi "slt", %0, %c0 : index
// CHECK-NEXT: %2 = addi %0, %c42 : index
// CHECK-NEXT: %3 = select %1, %2, %0 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: %{{.*}} = remis %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
%0 = affine.apply #mapmod (%arg0)
return %0 : index
}
@ -601,15 +601,15 @@ func @affine_apply_mod(%arg0 : index) -> (index) {
// --------------------------------------------------------------------------//
// CHECK-LABEL: func @affine_apply_floordiv
func @affine_apply_floordiv(%arg0 : index) -> (index) {
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c-1 = constant -1 : index
// CHECK-NEXT: %0 = cmpi "slt", %arg0, %c0 : index
// CHECK-NEXT: %1 = subi %c-1, %arg0 : index
// CHECK-NEXT: %2 = select %0, %1, %arg0 : index
// CHECK-NEXT: %3 = divis %2, %c42 : index
// CHECK-NEXT: %4 = subi %c-1, %3 : index
// CHECK-NEXT: %5 = select %0, %4, %3 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}}-1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = cmpi "slt", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = subi %{{.*}}-1, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = divis %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = subi %{{.*}}-1, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
%0 = affine.apply #mapfloordiv (%arg0)
return %0 : index
}
@ -623,17 +623,17 @@ func @affine_apply_floordiv(%arg0 : index) -> (index) {
// --------------------------------------------------------------------------//
// CHECK-LABEL: func @affine_apply_ceildiv
func @affine_apply_ceildiv(%arg0 : index) -> (index) {
// CHECK-NEXT: %c42 = constant 42 : index
// CHECK-NEXT: %c0 = constant 0 : index
// CHECK-NEXT: %c1 = constant 1 : index
// CHECK-NEXT: %0 = cmpi "sle", %arg0, %c0 : index
// CHECK-NEXT: %1 = subi %c0, %arg0 : index
// CHECK-NEXT: %2 = subi %arg0, %c1 : index
// CHECK-NEXT: %3 = select %0, %1, %2 : index
// CHECK-NEXT: %4 = divis %3, %c42 : index
// CHECK-NEXT: %5 = subi %c0, %4 : index
// CHECK-NEXT: %6 = addi %4, %c1 : index
// CHECK-NEXT: %7 = select %0, %5, %6 : index
// CHECK-NEXT: %{{.*}} = constant 42 : index
// CHECK-NEXT: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = constant 1 : index
// CHECK-NEXT: %{{.*}} = cmpi "sle", %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = divis %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = subi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = select %{{.*}}, %{{.*}}, %{{.*}} : index
%0 = affine.apply #mapceildiv (%arg0)
return %0 : index
}
@ -644,10 +644,10 @@ func @affine_load(%arg0 : index) {
affine.for %i0 = 0 to 10 {
%1 = affine.load %0[%i0 + symbol(%arg0) + 7] : memref<10xf32>
}
// CHECK: %3 = addi %1, %arg0 : index
// CHECK-NEXT: %c7 = constant 7 : index
// CHECK-NEXT: %4 = addi %3, %c7 : index
// CHECK-NEXT: %5 = load %0[%4] : memref<10xf32>
// CHECK: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 7 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = load %{{.*}}[%{{.*}}] : memref<10xf32>
return
}
@ -658,12 +658,12 @@ func @affine_store(%arg0 : index) {
affine.for %i0 = 0 to 10 {
affine.store %1, %0[%i0 - symbol(%arg0) + 7] : memref<10xf32>
}
// CHECK: %c-1 = constant -1 : index
// CHECK-NEXT: %3 = muli %arg0, %c-1 : index
// CHECK-NEXT: %4 = addi %1, %3 : index
// CHECK-NEXT: %c7 = constant 7 : index
// CHECK-NEXT: %5 = addi %4, %c7 : index
// CHECK-NEXT: store %cst, %0[%5] : memref<10xf32>
// CHECK: %{{.*}}-1 = constant -1 : index
// CHECK-NEXT: %{{.*}} = muli %{{.*}}, %{{.*}}-1 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 7 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
return
}
@ -678,11 +678,11 @@ func @affine_dma_start(%arg0 : index) {
affine.dma_start %0[%i0 + 7], %1[%arg0 + 11], %2[%c0], %c64
: memref<100xf32>, memref<100xf32, 2>, memref<1xi32>
}
// CHECK: %c7 = constant 7 : index
// CHECK-NEXT: %5 = addi %3, %c7 : index
// CHECK-NEXT: %c11 = constant 11 : index
// CHECK-NEXT: %6 = addi %arg0, %c11 : index
// CHECK-NEXT: dma_start %0[%5], %1[%6], %c64, %2[%c0] : memref<100xf32>, memref<100xf32, 2>, memref<1xi32>
// CHECK: %{{.*}} = constant 7 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 11 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}}], %{{.*}}, %{{.*}}[%{{.*}}] : memref<100xf32>, memref<100xf32, 2>, memref<1xi32>
return
}
@ -693,9 +693,9 @@ func @affine_dma_wait(%arg0 : index) {
affine.for %i0 = 0 to 10 {
affine.dma_wait %2[%i0 + %arg0 + 17], %c64 : memref<1xi32>
}
// CHECK: %3 = addi %1, %arg0 : index
// CHECK-NEXT: %c17 = constant 17 : index
// CHECK-NEXT: %4 = addi %3, %c17 : index
// CHECK-NEXT: dma_wait %0[%4], %c64 : memref<1xi32>
// CHECK: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: %{{.*}} = constant 17 : index
// CHECK-NEXT: %{{.*}} = addi %{{.*}}, %{{.*}} : index
// CHECK-NEXT: dma_wait %{{.*}}[%{{.*}}], %{{.*}} : memref<1xi32>
return
}

8
mlir/test/Transforms/memref-bound-check.mlir
View File

@ -71,10 +71,10 @@ func @test_no_out_of_bounds() {
affine.for %i = 0 to 256 {
affine.for %j = 0 to 256 {
// All of these accesses are in bound; check that no errors are emitted.
// CHECK: %3 = affine.apply {{#map.*}}(%i0, %i1)
// CHECK-NEXT: %4 = affine.load %0[%3, %c0] : memref<257x256xi32>
// CHECK-NEXT: %5 = affine.apply {{#map.*}}(%i0, %i0)
// CHECK-NEXT: %6 = affine.load %2[%5] : memref<1xi32>
// CHECK: %{{.*}} = affine.apply {{#map.*}}(%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<257x256xi32>
// CHECK-NEXT: %{{.*}} = affine.apply {{#map.*}}(%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<1xi32>
%idx0 = affine.apply (d0, d1) -> ( 64 * (d0 ceildiv 64))(%i, %j)
// Without GCDTightenInequalities(), the upper bound on the region
// accessed along first memref dimension would have come out as d0 <= 318

72
mlir/test/Transforms/memref-dataflow-opt.mlir
View File

@ -16,9 +16,9 @@ func @simple_store_load() {
%v1 = addf %v0, %v0 : f32
}
return
// CHECK: %cst = constant 7.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: %0 = addf %cst, %cst : f32
// CHECK: %{{.*}} = constant 7.000000e+00 : f32
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: }
// CHECK-NEXT: return
}
@ -41,13 +41,13 @@ func @multi_store_load() {
%v4 = mulf %v2, %v3 : f32
}
return
// CHECK: %c0 = constant 0 : index
// CHECK-NEXT: %cst = constant 7.000000e+00 : f32
// CHECK-NEXT: %cst_0 = constant 8.000000e+00 : f32
// CHECK-NEXT: %cst_1 = constant 9.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: %0 = addf %cst, %cst : f32
// CHECK-NEXT: %1 = mulf %cst_1, %cst_1 : f32
// CHECK: %{{.*}} = constant 0 : index
// CHECK-NEXT: %{{.*}} = constant 7.000000e+00 : f32
// CHECK-NEXT: %{{.*}} = constant 8.000000e+00 : f32
// CHECK-NEXT: %{{.*}} = constant 9.000000e+00 : f32
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = mulf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -73,19 +73,19 @@ func @store_load_affine_apply() -> memref<10x10xf32> {
}
// The memref and its stores won't be erased due to this memref return.
return %m : memref<10x10xf32>
// CHECK: %cst = constant 7.000000e+00 : f32
// CHECK-NEXT: %0 = alloc() : memref<10x10xf32>
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to 10 {
// CHECK-NEXT: %1 = affine.apply [[MAP0]](%i0, %i1)
// CHECK-NEXT: %2 = affine.apply [[MAP1]](%i0, %i1)
// CHECK-NEXT: %3 = affine.apply [[MAP2]](%1, %2)
// CHECK-NEXT: %4 = affine.apply [[MAP3]](%1, %2)
// CHECK-NEXT: affine.store %cst, %0[%3, %4] : memref<10x10xf32>
// CHECK-NEXT: %5 = addf %cst, %cst : f32
// CHECK: %{{.*}} = constant 7.000000e+00 : f32
// CHECK-NEXT: %{{.*}} = alloc() : memref<10x10xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP0]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP1]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP2]](%{{.*}}, %{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP3]](%{{.*}}, %{{.*}})
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<10x10xf32>
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return %0 : memref<10x10xf32>
// CHECK-NEXT: return %{{.*}} : memref<10x10xf32>
}
// CHECK-LABEL: func @store_load_nested
@ -100,10 +100,10 @@ func @store_load_nested(%N : index) {
}
}
return
// CHECK: %cst = constant 7.000000e+00 : f32
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.for %i1 = 0 to %arg0 {
// CHECK-NEXT: %0 = addf %cst, %cst : f32
// CHECK: %{{.*}} = constant 7.000000e+00 : f32
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to %{{.*}} {
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -123,7 +123,7 @@ func @multi_store_load_nested_no_fwd(%N : index) {
affine.store %cf8, %m[%i1] : memref<10xf32>
}
affine.for %i2 = 0 to %N {
// CHECK: %{{[0-9]+}} = affine.load %0[%i0] : memref<10xf32>
// CHECK: %{{[0-9]+}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
%v0 = affine.load %m[%i0] : memref<10xf32>
%v1 = addf %v0, %v0 : f32
}
@ -141,7 +141,7 @@ func @store_load_store_nested_no_fwd(%N : index) {
affine.for %i0 = 0 to 10 {
affine.store %cf7, %m[%i0] : memref<10xf32>
affine.for %i1 = 0 to %N {
// CHECK: %{{[0-9]+}} = affine.load %0[%i0] : memref<10xf32>
// CHECK: %{{[0-9]+}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
%v0 = affine.load %m[%i0] : memref<10xf32>
%v1 = addf %v0, %v0 : f32
affine.store %cf9, %m[%i0] : memref<10xf32>
@ -235,15 +235,15 @@ func @store_load_store_nested_fwd(%N : index) -> f32 {
// Due to this load, the memref isn't optimized away.
%v3 = affine.load %m[%c1] : memref<10xf32>
return %v3 : f32
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: affine.for %i0 = 0 to 10 {
// CHECK-NEXT: affine.store %cst, %0[%i0] : memref<10xf32>
// CHECK-NEXT: affine.for %i1 = 0 to %arg0 {
// CHECK-NEXT: %1 = addf %cst, %cst : f32
// CHECK-NEXT: %2 = affine.apply [[MAP4]](%i0)
// CHECK-NEXT: affine.store %cst_0, %0[%2] : memref<10xf32>
// CHECK: %{{.*}} = alloc() : memref<10xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 10 {
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: affine.for %{{.*}} = 0 to %{{.*}} {
// CHECK-NEXT: %{{.*}} = addf %{{.*}}, %{{.*}} : f32
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP4]](%{{.*}})
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: %3 = affine.load %0[%c1] : memref<10xf32>
// CHECK-NEXT: return %3 : f32
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}}] : memref<10xf32>
// CHECK-NEXT: return %{{.*}} : f32
}

134
mlir/test/Transforms/pipeline-data-transfer.mlir
View File

@ -28,35 +28,35 @@ func @loop_nest_dma() {
}
return
}
// CHECK: %0 = alloc() : memref<256xf32>
// CHECK: %1 = alloc() : memref<2x32xf32, 1>
// CHECK-NEXT: %2 = alloc() : memref<2x1xf32>
// CHECK-NEXT: affine.dma_start %0[%c0], %1[%c0 mod 2, %c0], %2[%c0 mod 2, symbol(%c0_0)], %c128 : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
// CHECK-NEXT: affine.for %i0 = 1 to 8 {
// CHECK-NEXT: affine.dma_start %0[%i0], %1[%i0 mod 2, %i0], %2[%i0 mod 2, symbol(%c0_0)], %c128 : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
// CHECK-NEXT: %3 = affine.apply [[MAP_MINUS_1]](%i0)
// CHECK-NEXT: %4 = affine.apply [[MOD_2]](%3)
// CHECK-NEXT: %5 = affine.apply [[MOD_2]](%3)
// CHECK-NEXT: affine.dma_wait %2[%3 mod 2, symbol(%c0_0)], %c128 : memref<2x1xf32>
// CHECK-NEXT: %6 = affine.load %1[%3 mod 2, %3] : memref<2x32xf32, 1>
// CHECK-NEXT: %7 = "compute"(%6) : (f32) -> f32
// CHECK-NEXT: affine.store %7, %1[%3 mod 2, %3] : memref<2x32xf32, 1>
// CHECK-NEXT: affine.for %i1 = 0 to 128 {
// CHECK-NEXT: "do_more_compute"(%3, %i1) : (index, index) -> ()
// CHECK: %{{.*}} = alloc() : memref<256xf32>
// CHECK: %{{.*}} = alloc() : memref<2x32xf32, 1>
// CHECK-NEXT: %{{.*}} = alloc() : memref<2x1xf32>
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}} mod 2, %{{.*}}], %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}})], %{{.*}} : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
// CHECK-NEXT: affine.for %{{.*}} = 1 to 8 {
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[%{{.*}} mod 2, %{{.*}}], %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}})], %{{.*}} : memref<256xf32>, memref<2x32xf32, 1>, memref<2x1xf32>
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_MINUS_1]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MOD_2]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MOD_2]](%{{.*}})
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}})], %{{.*}} : memref<2x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1>
// CHECK-NEXT: %{{.*}} = "compute"(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 128 {
// CHECK-NEXT: "do_more_compute"(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: %8 = affine.apply [[MAP_MINUS_1]](%c8)
// CHECK-NEXT: %9 = affine.apply [[MOD_2]](%8)
// CHECK-NEXT: %10 = affine.apply [[MOD_2]](%8)
// CHECK-NEXT: affine.dma_wait %2[%8 mod 2, symbol(%c0_0)], %c128 : memref<2x1xf32>
// CHECK-NEXT: %11 = affine.load %1[%8 mod 2, %8] : memref<2x32xf32, 1>
// CHECK-NEXT: %12 = "compute"(%11) : (f32) -> f32
// CHECK-NEXT: affine.store %12, %1[%8 mod 2, %8] : memref<2x32xf32, 1>
// CHECK-NEXT: affine.for %i2 = 0 to 128 {
// CHECK-NEXT: "do_more_compute"(%8, %i2) : (index, index) -> ()
// CHECK-NEXT: %{{.*}} = affine.apply [[MAP_MINUS_1]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MOD_2]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[MOD_2]](%{{.*}})
// CHECK-NEXT: affine.dma_wait %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}})], %{{.*}} : memref<2x1xf32>
// CHECK-NEXT: %{{.*}} = affine.load %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1>
// CHECK-NEXT: %{{.*}} = "compute"(%{{.*}}) : (f32) -> f32
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%{{.*}} mod 2, %{{.*}}] : memref<2x32xf32, 1>
// CHECK-NEXT: affine.for %{{.*}} = 0 to 128 {
// CHECK-NEXT: "do_more_compute"(%{{.*}}, %{{.*}}) : (index, index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: dealloc %2 : memref<2x1xf32>
// CHECK-NEXT: dealloc %1 : memref<2x32xf32, 1>
// CHECK-NEXT: dealloc %{{.*}} : memref<2x1xf32>
// CHECK-NEXT: dealloc %{{.*}} : memref<2x32xf32, 1>
// CHECK-NEXT: return
// CHECK-NEXT:}
@ -81,18 +81,18 @@ func @loop_step(%arg0: memref<512xf32>,
return
}
// CHECK: [[TAG:%[0-9]+]] = alloc() : memref<2x1xi32>
// CHECK-NEXT: affine.dma_start %arg0[%c0], %0[(%c0 floordiv 4) mod 2, symbol(%c0_0)], [[TAG]][(%c0 floordiv 4) mod 2, symbol(%c0_0)], %c4 : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32>
// CHECK-NEXT: affine.for %i0 = 4 to 512 step 4 {
// CHECK-NEXT: affine.dma_start %arg0[%i0], %0[(%i0 floordiv 4) mod 2, symbol(%c0_0)], [[TAG]][(%i0 floordiv 4) mod 2, symbol(%c0_0)], %c4 : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32>
// CHECK-NEXT: %2 = affine.apply [[REMAP_SHIFT_MINUS_4]](%i0)
// CHECK-NEXT: %3 = affine.apply [[FLOOR_MOD_2]](%2)
// CHECK: affine.dma_wait [[TAG]][(%2 floordiv 4) mod 2, symbol(%c0_0)], %c4 : memref<2x1xi32>
// CHECK-NEXT: "compute"(%2) : (index) -> ()
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[(%{{.*}} floordiv 4) mod 2, symbol(%{{.*}})], [[TAG]][(%{{.*}} floordiv 4) mod 2, symbol(%{{.*}})], %{{.*}} : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32>
// CHECK-NEXT: affine.for %{{.*}} = 4 to 512 step 4 {
// CHECK-NEXT: affine.dma_start %{{.*}}[%{{.*}}], %{{.*}}[(%{{.*}} floordiv 4) mod 2, symbol(%{{.*}})], [[TAG]][(%{{.*}} floordiv 4) mod 2, symbol(%{{.*}})], %{{.*}} : memref<512xf32>, memref<2x4xf32, 1>, memref<2x1xi32>
// CHECK-NEXT: %{{.*}} = affine.apply [[REMAP_SHIFT_MINUS_4]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[FLOOR_MOD_2]](%{{.*}})
// CHECK: affine.dma_wait [[TAG]][(%{{.*}} floordiv 4) mod 2, symbol(%{{.*}})], %{{.*}} : memref<2x1xi32>
// CHECK-NEXT: "compute"(%{{.*}}) : (index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: [[SHIFTED:%[0-9]+]] = affine.apply [[REMAP_SHIFT_MINUS_4]](%c512)
// CHECK-NEXT: %6 = affine.apply [[FLOOR_MOD_2]]([[SHIFTED]])
// CHECK: affine.dma_wait [[TAG]][(%5 floordiv 4) mod 2, symbol(%c0_0)], %c4 : memref<2x1xi32>
// CHECK-NEXT: "compute"(%5) : (index) -> ()
// CHECK-NEXT: [[SHIFTED:%[0-9]+]] = affine.apply [[REMAP_SHIFT_MINUS_4]](%{{.*}})
// CHECK-NEXT: %{{.*}} = affine.apply [[FLOOR_MOD_2]]([[SHIFTED]])
// CHECK: affine.dma_wait [[TAG]][(%{{.*}} floordiv 4) mod 2, symbol(%{{.*}})], %{{.*}} : memref<2x1xi32>
// CHECK-NEXT: "compute"(%{{.*}}) : (index) -> ()
// CHECK: return
// CHECK-NEXT: }
@ -101,7 +101,7 @@ func @loop_step(%arg0: memref<512xf32>,
#map0 = (d0, d1) -> (d0, d1)
#map1 = (d0, d1) -> ((d0 * 2048 + d1 * 256) floordiv 32)
#map2 = (d0) -> ((d0 * 2048) floordiv 32)
// CHECK-LABEL: func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>
// CHECK-LABEL: func @loop_dma_nested(%{{.*}}: memref<512x32xvector<8xf32>
func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>, #map0>, %arg1: memref<512x32xvector<8xf32>, #map0>, %arg2: memref<512x32xvector<8xf32>, #map0>) {
%num_elts = constant 256 : index
%c0 = constant 0 : index
@ -114,23 +114,23 @@ func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>, #map0>, %arg1: memref<
// Prologue for DMA overlap on arg2.
// CHECK-DAG: [[BUF_ARG2:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
// CHECK-DAG: [[TAG_ARG2:%[0-9]+]] = alloc() : memref<2x2xi32>
// CHECK: affine.dma_start %arg2[
// CHECK: affine.for %i0 = 1 to 8 {
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.for %{{.*}} = 1 to 8 {
affine.for %i0 = 0 to 8 {
%6 = affine.apply #map2(%i0)
affine.dma_start %arg2[%6, %c0], %2[%c0, %c0], %5[%c0], %num_elts : memref<512x32xvector<8xf32>, #map0>, memref<64x4xvector<8xf32>, #map0, 2>, memref<2xi32>
affine.dma_wait %5[%c0], %num_elts : memref<2xi32>
// Steady state for DMA overlap on arg2
// CHECK: affine.dma_start %arg2[
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.dma_wait [[TAG_ARG2]]
// Prologue for DMA overlap on arg0, arg1 nested within i0
// CHECK: [[BUF_ARG0:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
// CHECK: [[BUF_ARG1:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
// CHECK: [[TAG_ARG0:%[0-9]+]] = alloc() : memref<2x2xi32>
// CHECK: [[TAG_ARG1:%[0-9]+]] = alloc() : memref<2x2xi32>
// CHECK: affine.dma_start %arg0[
// CHECK: affine.dma_start %arg1[
// CHECK-NEXT affine.for %i1 = 1 to 8 {
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.dma_start %{{.*}}[
// CHECK-NEXT affine.for %{{.*}} = 1 to 8 {
affine.for %i1 = 0 to 8 {
%7 = affine.apply #map1(%i0, %i1)
%8 = affine.apply #map2(%i1)
@ -139,11 +139,11 @@ func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>, #map0>, %arg1: memref<
affine.dma_wait %3[%c0], %num_elts : memref<2xi32>
affine.dma_wait %4[%c0], %num_elts : memref<2xi32>
// Steady state for DMA overlap on arg0, arg1
// CHECK: affine.dma_start %arg0[
// CHECK: affine.dma_start %arg1[
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.dma_wait [[TAG_ARG0]]
// CHECK: affine.dma_wait [[TAG_ARG1]]
// CHECK-NEXT: affine.for %i2 = 0 to 4 {
// CHECK-NEXT: affine.for %{{.*}} = 0 to 4 {
affine.for %i2 = 0 to 4 {
"foo"() : () -> ()
}
@ -162,18 +162,18 @@ func @loop_dma_nested(%arg0: memref<512x32xvector<8xf32>, #map0>, %arg1: memref<
// CHECK: [[BUF_ARG1_NESTED:%[0-9]+]] = alloc() : memref<2x64x4xvector<8xf32>, 2>
// CHECK: [[TAG_ARG0_NESTED:%[0-9]+]] = alloc() : memref<2x2xi32>
// CHECK: [[TAG_ARG1_NESTED:%[0-9]+]] = alloc() : memref<2x2xi32>
// CHECK: affine.dma_start %arg0[
// CHECK: affine.dma_start %arg1[
// CHECK: affine.for %i4 = 1 to 8 {
// CHECK: affine.dma_start %arg0[
// CHECK: affine.dma_start %arg1[
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.for %{{.*}} = 1 to 8 {
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.dma_start %{{.*}}[
// CHECK: affine.dma_wait [[TAG_ARG0_NESTED]]
// CHECK: affine.dma_wait [[TAG_ARG1_NESTED]]
// CHECK: affine.for %i5 = 0 to 4 {
// CHECK: affine.for %{{.*}} = 0 to 4 {
// CHECK: "foo"() : () -> ()
// CHECK: affine.dma_wait [[TAG_ARG0_NESTED]]
// CHECK: affine.dma_wait [[TAG_ARG1_NESTED]]
// CHECK: affine.for %i6 = 0 to 4 {
// CHECK: affine.for %{{.*}} = 0 to 4 {
}
return
// CHECK: }
@ -203,7 +203,7 @@ func @loop_dma_dependent(%arg2: memref<512x32xvector<8xf32>>) {
// The two DMAs below are dependent (incoming and outgoing on the same
// memref) in the same iteration; so no pipelining here.
// CHECK-NOT: affine.dma_start
// CHECK: affine.for %i0 = 0 to 8 {
// CHECK: affine.for %{{.*}} = 0 to 8 {
affine.for %i0 = 0 to 8 {
%6 = affine.apply #map2(%i0)
affine.dma_start %arg2[%6, %c0], %2[%c0, %c0], %5[%c0], %num_elts : memref<512x32xvector<8xf32>>, memref<64x4xvector<8xf32>, 2>, memref<2xi32>
@ -226,7 +226,7 @@ func @escaping_use(%arg0: memref<512 x 32 x f32>) {
%tag = alloc() : memref<1 x i32>
// CHECK-NOT: affine.dma_start
// CHECK: affine.for %i0 = 0 to 16 {
// CHECK: affine.for %{{.*}} = 0 to 16 {
affine.for %kTT = 0 to 16 {
affine.dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %tag[%zero], %num_elt :
memref<512 x 32 x f32>,
@ -252,7 +252,7 @@ func @live_out_use(%arg0: memref<512 x 32 x f32>) -> f32 {
%tag = alloc() : memref<1 x i32>
// CHECK-NOT: affine.dma_start
// CHECK: affine.for %i0 = 0 to 16 {
// CHECK: affine.for %{{.*}} = 0 to 16 {
affine.for %kTT = 0 to 16 {
affine.dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %tag[%zero], %num_elt :
memref<512 x 32 x f32>,
@ -262,7 +262,7 @@ func @live_out_use(%arg0: memref<512 x 32 x f32>) -> f32 {
// Use live out of 'affine.for' op; no DMA pipelining will be done.
%v = affine.load %Av[%zero, %zero] : memref<32 x 32 x f32, 2>
return %v : f32
// CHECK: %{{[0-9]+}} = affine.load %{{[0-9]+}}[%c0, %c0] : memref<32x32xf32, 2>
// CHECK: %{{[0-9]+}} = affine.load %{{[0-9]+}}[%{{.*}}, %{{.*}}] : memref<32x32xf32, 2>
// CHECK: return
}
@ -278,11 +278,11 @@ func @dynamic_shape_dma_buffer(%arg0: memref<512 x 32 x f32>) {
%tag = alloc() : memref<1 x i32>
// Double buffering for dynamic shaped buffer.
// CHECK: %0 = alloc(%c32, %c32) : memref<?x?xf32, 2>
// CHECK-NEXT: %1 = dim %0, 0 : memref<?x?xf32, 2>
// CHECK-NEXT: %2 = dim %0, 1 : memref<?x?xf32, 2>
// CHECK-NEXT: %3 = alloc(%1, %2) : memref<2x?x?xf32, 2>
// CHECK: affine.dma_start %arg0[%c0_0, %c0_0], %3[%c0 mod 2, symbol(%c0_0), symbol(%c0_0)], %4[%c0 mod 2, symbol(%c0_0)], %c512
// CHECK: %{{.*}} = alloc(%{{.*}}, %{{.*}}) : memref<?x?xf32, 2>
// CHECK-NEXT: %{{.*}} = dim %{{.*}}, 0 : memref<?x?xf32, 2>
// CHECK-NEXT: %{{.*}} = dim %{{.*}}, 1 : memref<?x?xf32, 2>
// CHECK-NEXT: %{{.*}} = alloc(%{{.*}}, %{{.*}}) : memref<2x?x?xf32, 2>
// CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}}), symbol(%{{.*}})], %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}})], %{{.*}}
affine.for %kTT = 0 to 16 {
affine.dma_start %arg0[%zero, %zero], %Av[%zero, %zero], %tag[%zero], %num_elt :
memref<512 x 32 x f32>,
@ -290,10 +290,10 @@ func @dynamic_shape_dma_buffer(%arg0: memref<512 x 32 x f32>) {
affine.dma_wait %tag[%zero], %num_elt : memref<1 x i32>
}
return
// CHECK-NEXT: affine.for %i0 = 1 to 16 {
// CHECK: affine.dma_start %arg0[%c0_0, %c0_0], %3[%i0 mod 2, symbol(%c0_0), symbol(%c0_0)], %4[%i0 mod 2, symbol(%c0_0)], %c512
// CHECK: affine.dma_wait %4[%5 mod 2, symbol(%c0_0)], %c512 : memref<2x1xi32>
// CHECK-NEXT: affine.for %{{.*}} = 1 to 16 {
// CHECK: affine.dma_start %{{.*}}[%{{.*}}, %{{.*}}], %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}}), symbol(%{{.*}})], %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}})], %{{.*}}
// CHECK: affine.dma_wait %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}})], %{{.*}} : memref<2x1xi32>
// CHECK: }
// CHECK: affine.dma_wait %4[%8 mod 2, symbol(%c0_0)], %c512 : memref<2x1xi32>
// CHECK: affine.dma_wait %{{.*}}[%{{.*}} mod 2, symbol(%{{.*}})], %{{.*}} : memref<2x1xi32>
// CHECK: return
}

78
mlir/test/Transforms/simplify-affine-structures.mlir
View File

@ -73,10 +73,10 @@
// CHECK-LABEL: func @test_gaussian_elimination_empty_set0() {
func @test_gaussian_elimination_empty_set0() {
affine.for %i0 = 1 to 10 {
affine.for %i1 = 1 to 100 {
// CHECK: [[SET_EMPTY_2D]](%i0, %i1)
affine.if (d0, d1) : (2 == 0)(%i0, %i1) {
affine.for %arg0 = 1 to 10 {
affine.for %arg1 = 1 to 100 {
// CHECK: [[SET_EMPTY_2D]](%arg0, %arg1)
affine.if (d0, d1) : (2 == 0)(%arg0, %arg1) {
}
}
}
@ -85,10 +85,10 @@ func @test_gaussian_elimination_empty_set0() {
// CHECK-LABEL: func @test_gaussian_elimination_empty_set1() {
func @test_gaussian_elimination_empty_set1() {
affine.for %i0 = 1 to 10 {
affine.for %i1 = 1 to 100 {
// CHECK: [[SET_EMPTY_2D]](%i0, %i1)
affine.if (d0, d1) : (1 >= 0, -1 >= 0) (%i0, %i1) {
affine.for %arg0 = 1 to 10 {
affine.for %arg1 = 1 to 100 {
// CHECK: [[SET_EMPTY_2D]](%arg0, %arg1)
affine.if (d0, d1) : (1 >= 0, -1 >= 0) (%arg0, %arg1) {
}
}
}
@ -97,10 +97,10 @@ func @test_gaussian_elimination_empty_set1() {
// CHECK-LABEL: func @test_gaussian_elimination_non_empty_set2() {
func @test_gaussian_elimination_non_empty_set2() {
affine.for %i0 = 1 to 10 {
affine.for %i1 = 1 to 100 {
// CHECK: #set1(%i0, %i1)
affine.if #set2(%i0, %i1) {
affine.for %arg0 = 1 to 10 {
affine.for %arg1 = 1 to 100 {
// CHECK: #set1(%arg0, %arg1)
affine.if #set2(%arg0, %arg1) {
}
}
}
@ -111,10 +111,10 @@ func @test_gaussian_elimination_non_empty_set2() {
func @test_gaussian_elimination_empty_set3() {
%c7 = constant 7 : index
%c11 = constant 11 : index
affine.for %i0 = 1 to 10 {
affine.for %i1 = 1 to 100 {
// CHECK: #set2(%i0, %i1)[%c7, %c11]
affine.if #set3(%i0, %i1)[%c7, %c11] {
affine.for %arg0 = 1 to 10 {
affine.for %arg1 = 1 to 100 {
// CHECK: #set2(%arg0, %arg1)[%c7, %c11]
affine.if #set3(%arg0, %arg1)[%c7, %c11] {
}
}
}
@ -125,10 +125,10 @@ func @test_gaussian_elimination_empty_set3() {
func @test_gaussian_elimination_non_empty_set4() {
%c7 = constant 7 : index
%c11 = constant 11 : index
affine.for %i0 = 1 to 10 {
affine.for %i1 = 1 to 100 {
// CHECK: #set3(%i0, %i1)[%c7, %c11]
affine.if #set4(%i0, %i1)[%c7, %c11] {
affine.for %arg0 = 1 to 10 {
affine.for %arg1 = 1 to 100 {
// CHECK: #set3(%arg0, %arg1)[%c7, %c11]
affine.if #set4(%arg0, %arg1)[%c7, %c11] {
}
}
}
@ -139,10 +139,10 @@ func @test_gaussian_elimination_non_empty_set4() {
func @test_gaussian_elimination_empty_set5() {
%c7 = constant 7 : index
%c11 = constant 11 : index
affine.for %i0 = 1 to 10 {
affine.for %i1 = 1 to 100 {
// CHECK: #set2(%i0, %i1)[%c7, %c11]
affine.if #set5(%i0, %i1)[%c7, %c11] {
affine.for %arg0 = 1 to 10 {
affine.for %arg1 = 1 to 100 {
// CHECK: #set2(%arg0, %arg1)[%c7, %c11]
affine.if #set5(%arg0, %arg1)[%c7, %c11] {
}
}
}
@ -151,9 +151,9 @@ func @test_gaussian_elimination_empty_set5() {
// CHECK-LABEL: func @test_fuzz_explosion
func @test_fuzz_explosion(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : index) {
affine.for %i0 = 1 to 10 {
affine.for %i1 = 1 to 100 {
affine.if #set_fuzz_virus(%i0, %i1, %arg0, %arg1, %arg2, %arg3) {
affine.for %arg4 = 1 to 10 {
affine.for %arg5 = 1 to 100 {
affine.if #set_fuzz_virus(%arg4, %arg5, %arg0, %arg1, %arg2, %arg3) {
}
}
}
@ -165,33 +165,33 @@ func @test_fuzz_explosion(%arg0 : index, %arg1 : index, %arg2 : index, %arg3 : i
func @test_empty_set(%N : index) {
affine.for %i = 0 to 10 {
affine.for %j = 0 to 10 {
// CHECK: affine.if [[SET_EMPTY_2D]](%i0, %i1)
// CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
affine.if (d0, d1) : (d0 - d1 >= 0, d1 - d0 - 1 >= 0)(%i, %j) {
"foo"() : () -> ()
}
// CHECK: affine.if [[SET_EMPTY_1D]](%i0)
// CHECK: affine.if [[SET_EMPTY_1D]](%arg1)
affine.if (d0) : (d0 >= 0, -d0 - 1 >= 0)(%i) {
"bar"() : () -> ()
}
// CHECK: affine.if [[SET_EMPTY_1D]](%i0)
// CHECK: affine.if [[SET_EMPTY_1D]](%arg1)
affine.if (d0) : (d0 >= 0, -d0 - 1 >= 0)(%i) {
"foo"() : () -> ()
}
// CHECK: affine.if [[SET_EMPTY_1D_2S]](%i0)[%arg0, %arg0]
// CHECK: affine.if [[SET_EMPTY_1D_2S]](%arg1)[%arg0, %arg0]
affine.if (d0)[s0, s1] : (d0 >= 0, -d0 + s0 - 1 >= 0, -s0 >= 0)(%i)[%N, %N] {
"bar"() : () -> ()
}
// CHECK: affine.if [[SET_EMPTY_3D]](%i0, %i1, %arg0)
// CHECK: affine.if [[SET_EMPTY_3D]](%arg1, %arg2, %arg0)
// The set below implies d0 = d1; so d1 >= d0, but d0 >= d1 + 1.
affine.if (d0, d1, d2) : (d0 - d1 == 0, d2 - d0 >= 0, d0 - d1 - 1 >= 0)(%i, %j, %N) {
"foo"() : () -> ()
}
// CHECK: affine.if [[SET_EMPTY_2D]](%i0, %i1)
// CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
// The set below has rational solutions but no integer solutions; GCD test catches it.
affine.if (d0, d1) : (d0*2 -d1*2 - 1 == 0, d0 >= 0, -d0 + 100 >= 0, d1 >= 0, -d1 + 100 >= 0)(%i, %j) {
"foo"() : () -> ()
}
// CHECK: affine.if [[SET_EMPTY_2D]](%i0, %i1)
// CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
affine.if (d0, d1) : (d1 == 0, d0 - 1 >= 0, - d0 - 1 >= 0)(%i, %j) {
"foo"() : () -> ()
}
@ -201,12 +201,12 @@ func @test_empty_set(%N : index) {
affine.for %k = 0 to 10 {
affine.for %l = 0 to 10 {
// Empty because no multiple of 8 lies between 4 and 7.
// CHECK: affine.if [[SET_EMPTY_1D]](%i2)
// CHECK: affine.if [[SET_EMPTY_1D]](%arg1)
affine.if (d0) : (8*d0 - 4 >= 0, -8*d0 + 7 >= 0)(%k) {
"foo"() : () -> ()
}
// Same as above but with equalities and inequalities.
// CHECK: affine.if [[SET_EMPTY_2D]](%i2, %i3)
// CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
affine.if (d0, d1) : (d0 - 4*d1 == 0, 4*d1 - 5 >= 0, -4*d1 + 7 >= 0)(%k, %l) {
"foo"() : () -> ()
}
@ -214,12 +214,12 @@ func @test_empty_set(%N : index) {
// 8*d1 here is a multiple of 4, and so can't lie between 9 and 11. GCD
// tightening will tighten constraints to 4*d0 + 8*d1 >= 12 and 4*d0 +
// 8*d1 <= 8; hence infeasible.
// CHECK: affine.if [[SET_EMPTY_2D]](%i2, %i3)
// CHECK: affine.if [[SET_EMPTY_2D]](%arg1, %arg2)
affine.if (d0, d1) : (4*d0 + 8*d1 - 9 >= 0, -4*d0 - 8*d1 + 11 >= 0)(%k, %l) {
"foo"() : () -> ()
}
// Same as above but with equalities added into the mix.
// CHECK: affine.if [[SET_EMPTY_3D]](%i2, %i2, %i3)
// CHECK: affine.if [[SET_EMPTY_3D]](%arg1, %arg1, %arg2)
affine.if (d0, d1, d2) : (d0 - 4*d2 == 0, d0 + 8*d1 - 9 >= 0, -d0 - 8*d1 + 11 >= 0)(%k, %k, %l) {
"foo"() : () -> ()
}
@ -227,7 +227,7 @@ func @test_empty_set(%N : index) {
}
affine.for %m = 0 to 10 {
// CHECK: affine.if [[SET_EMPTY_1D]](%i{{[0-9]+}})
// CHECK: affine.if [[SET_EMPTY_1D]](%arg{{[0-9]+}})
affine.if (d0) : (d0 mod 2 - 3 == 0) (%m) {
"foo"() : () -> ()
}

4
mlir/test/Transforms/test-legalizer.mlir
View File

@ -53,8 +53,8 @@ func @remap_multi(%arg0: i64, %unused: i16, %arg1: i64) -> (i64, i64) {
func @remap_nested() {
// CHECK-NEXT: "foo.region"
"foo.region"() ({
// CHECK-NEXT: ^bb1(%i0: f64, %i1: f64):
^bb1(%i0: i64, %unused: i16, %i1: i64):
// CHECK-NEXT: ^bb0(%{{.*}}: f64, %{{.*}}: f64):
^bb0(%i0: i64, %unused: i16, %i1: i64):
// CHECK-NEXT: "test.valid"{{.*}} : (f64, f64)
"test.invalid"(%i0, %i1) : (i64, i64) -> ()
}) : () -> ()

76
mlir/test/Transforms/unroll-jam.mlir
View File

@ -8,48 +8,48 @@
// CHECK-LABEL: func @unroll_jam_imperfect_nest() {
func @unroll_jam_imperfect_nest() {
// CHECK: %c100 = constant 100 : index
// CHECK-NEXT: affine.for %i0 = 0 to 100 step 2 {
// CHECK-NEXT: affine.for %arg0 = 0 to 100 step 2 {
affine.for %i = 0 to 101 {
// CHECK: %0 = "addi32"(%i0, %i0) : (index, index) -> i32
// CHECK-NEXT: %1 = affine.apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %2 = "addi32"(%1, %1) : (index, index) -> i32
// CHECK: "addi32"(%arg0, %arg0) : (index, index) -> i32
// CHECK-NEXT: %3 = affine.apply [[MAP_PLUS_1]](%arg0)
// CHECK-NEXT: "addi32"(%3, %3) : (index, index) -> i32
%x = "addi32"(%i, %i) : (index, index) -> i32
affine.for %j = 0 to 17 {
// CHECK: %3 = "addi32"(%i0, %i0) : (index, index) -> i32
// CHECK-NEXT: %4 = "addi32"(%3, %3) : (i32, i32) -> i32
// CHECK-NEXT: %5 = affine.apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> i32
// CHECK-NEXT: %7 = "addi32"(%6, %6) : (i32, i32) -> i32
// CHECK: %8 = "addi32"(%arg0, %arg0) : (index, index) -> i32
// CHECK-NEXT: "addi32"(%8, %8) : (i32, i32) -> i32
// CHECK-NEXT: %10 = affine.apply [[MAP_PLUS_1]](%arg0)
// CHECK-NEXT: %11 = "addi32"(%10, %10) : (index, index) -> i32
// CHECK-NEXT: "addi32"(%11, %11) : (i32, i32) -> i32
%y = "addi32"(%i, %i) : (index, index) -> i32
%z = "addi32"(%y, %y) : (i32, i32) -> i32
}
// CHECK: %8 = "addi32"(%i0, %i0) : (index, index) -> i32
// CHECK-NEXT: %9 = affine.apply [[MAP_PLUS_1]](%i0)
// CHECK-NEXT: %10 = "addi32"(%9, %9) : (index, index) -> i32
// CHECK: "addi32"(%arg0, %arg0) : (index, index) -> i32
// CHECK-NEXT: %6 = affine.apply [[MAP_PLUS_1]](%arg0)
// CHECK-NEXT: "addi32"(%6, %6) : (index, index) -> i32
%w = "addi32"(%i, %i) : (index, index) -> i32
} // CHECK }
// cleanup loop (single iteration)
// CHECK: %11 = "addi32"(%c100, %c100) : (index, index) -> i32
// CHECK-NEXT: affine.for %i2 = 0 to 17 {
// CHECK-NEXT: %12 = "addi32"(%c100, %c100) : (index, index) -> i32
// CHECK-NEXT: %13 = "addi32"(%12, %12) : (i32, i32) -> i32
// CHECK: "addi32"(%c100, %c100) : (index, index) -> i32
// CHECK-NEXT: affine.for %arg0 = 0 to 17 {
// CHECK-NEXT: %2 = "addi32"(%c100, %c100) : (index, index) -> i32
// CHECK-NEXT: "addi32"(%2, %2) : (i32, i32) -> i32
// CHECK-NEXT: }
// CHECK-NEXT: %14 = "addi32"(%c100, %c100) : (index, index) -> i32
// CHECK-NEXT: "addi32"(%c100, %c100) : (index, index) -> i32
return
}
// CHECK-LABEL: func @loop_nest_unknown_count_1(%arg0: index) {
func @loop_nest_unknown_count_1(%N : index) {
// CHECK-NEXT: affine.for %i0 = 1 to [[MAP_DIV_OFFSET]]()[%arg0] step 2 {
// CHECK-NEXT: affine.for %i1 = 1 to 100 {
// CHECK-NEXT: affine.for %arg1 = 1 to [[MAP_DIV_OFFSET]]()[%arg0] step 2 {
// CHECK-NEXT: affine.for %arg2 = 1 to 100 {
// CHECK-NEXT: %0 = "foo"() : () -> i32
// CHECK-NEXT: %1 = "foo"() : () -> i32
// CHECK-NEXT: }
// CHECK-NEXT: }
// A cleanup loop should be generated here.
// CHECK-NEXT: affine.for %i2 = [[MAP_DIV_OFFSET]]()[%arg0] to %arg0 {
// CHECK-NEXT: affine.for %i3 = 1 to 100 {
// CHECK-NEXT: %2 = "foo"() : () -> i32
// CHECK-NEXT: affine.for %arg1 = [[MAP_DIV_OFFSET]]()[%arg0] to %arg0 {
// CHECK-NEXT: affine.for %arg2 = 1 to 100 {
// CHECK-NEXT: "foo"() : () -> i32
// CHECK_NEXT: }
// CHECK_NEXT: }
affine.for %i = 1 to %N {
@ -62,17 +62,17 @@ func @loop_nest_unknown_count_1(%N : index) {
// CHECK-LABEL: func @loop_nest_unknown_count_2(%arg0: index) {
func @loop_nest_unknown_count_2(%arg : index) {
// CHECK-NEXT: affine.for %i0 = %arg0 to [[M1]]()[%arg0] step 2 {
// CHECK-NEXT: affine.for %i1 = 1 to 100 {
// CHECK-NEXT: %0 = "foo"(%i0) : (index) -> i32
// CHECK-NEXT: %1 = affine.apply #map{{[0-9]+}}(%i0)
// CHECK-NEXT: %2 = "foo"(%1) : (index) -> i32
// CHECK-NEXT: affine.for %arg1 = %arg0 to [[M1]]()[%arg0] step 2 {
// CHECK-NEXT: affine.for %arg2 = 1 to 100 {
// CHECK-NEXT: "foo"(%arg1) : (index) -> i32
// CHECK-NEXT: %2 = affine.apply #map{{[0-9]+}}(%arg1)
// CHECK-NEXT: "foo"(%2) : (index) -> i32
// CHECK-NEXT: }
// CHECK-NEXT: }
// The cleanup loop is a single iteration one and is promoted.
// CHECK-NEXT: %3 = affine.apply [[M1]]()[%arg0]
// CHECK-NEXT: affine.for %i2 = 1 to 100 {
// CHECK-NEXT: %4 = "foo"(%3) : (index) -> i32
// CHECK-NEXT: %0 = affine.apply [[M1]]()[%arg0]
// CHECK-NEXT: affine.for %arg1 = 1 to 100 {
// CHECK-NEXT: "foo"(%0) : (index) -> i32
// CHECK_NEXT: }
affine.for %i = %arg to ()[s0] -> (s0+9) ()[%arg] {
affine.for %j = 1 to 100 {
@ -91,16 +91,16 @@ func @loop_nest_symbolic_and_min_upper_bound(%M : index, %N : index, %K : index)
}
return
}
// CHECK-NEXT: affine.for %i0 = 0 to min [[MAP_MULTI_RES]]()[%arg0, %arg1] step 2 {
// CHECK-NEXT: affine.for %i1 = 0 to %arg2 {
// CHECK-NEXT: "foo"(%i0, %i1) : (index, index) -> ()
// CHECK-NEXT: %0 = affine.apply #map0(%i0)
// CHECK-NEXT: "foo"(%0, %i1) : (index, index) -> ()
// CHECK-NEXT: affine.for %arg3 = 0 to min [[MAP_MULTI_RES]]()[%arg0, %arg1] step 2 {
// CHECK-NEXT: affine.for %arg4 = 0 to %arg2 {
// CHECK-NEXT: "foo"(%arg3, %arg4) : (index, index) -> ()
// CHECK-NEXT: %0 = affine.apply #map0(%arg3)
// CHECK-NEXT: "foo"(%0, %arg4) : (index, index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: affine.for %i2 = max [[MAP_MULTI_RES]]()[%arg0, %arg1] to min #map9()[%arg0, %arg1] {
// CHECK-NEXT: affine.for %i3 = 0 to %arg2 {
// CHECK-NEXT: "foo"(%i2, %i3) : (index, index) -> ()
// CHECK-NEXT: affine.for %arg3 = max [[MAP_MULTI_RES]]()[%arg0, %arg1] to min #map9()[%arg0, %arg1] {
// CHECK-NEXT: affine.for %arg4 = 0 to %arg2 {
// CHECK-NEXT: "foo"(%arg3, %arg4) : (index, index) -> ()
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: return

110
mlir/test/Transforms/unroll.mlir
View File

@ -25,7 +25,7 @@
// UNROLL-FULL-LABEL: func @loop_nest_simplest() {
func @loop_nest_simplest() {
// UNROLL-FULL: affine.for %i0 = 0 to 100 step 2 {
// UNROLL-FULL: affine.for %arg0 = 0 to 100 step 2 {
affine.for %i = 0 to 100 step 2 {
// UNROLL-FULL: %c1_i32 = constant 1 : i32
// UNROLL-FULL-NEXT: %c1_i32_0 = constant 1 : i32
@ -41,7 +41,7 @@ func @loop_nest_simplest() {
// UNROLL-FULL-LABEL: func @loop_nest_simple_iv_use() {
func @loop_nest_simple_iv_use() {
// UNROLL-FULL: %c0 = constant 0 : index
// UNROLL-FULL-NEXT: affine.for %i0 = 0 to 100 step 2 {
// UNROLL-FULL-NEXT: affine.for %arg0 = 0 to 100 step 2 {
affine.for %i = 0 to 100 step 2 {
// UNROLL-FULL: %0 = "addi32"(%c0, %c0) : (index, index) -> i32
// UNROLL-FULL: %1 = affine.apply [[MAP0]](%c0)
@ -61,7 +61,7 @@ func @loop_nest_simple_iv_use() {
// UNROLL-FULL-LABEL: func @loop_nest_body_def_use() {
func @loop_nest_body_def_use() {
// UNROLL-FULL: %c0 = constant 0 : index
// UNROLL-FULL-NEXT: affine.for %i0 = 0 to 100 step 2 {
// UNROLL-FULL-NEXT: affine.for %arg0 = 0 to 100 step 2 {
affine.for %i = 0 to 100 step 2 {
// UNROLL-FULL: %c0_0 = constant 0 : index
%c0 = constant 0 : index
@ -89,7 +89,7 @@ func @loop_nest_body_def_use() {
func @loop_nest_strided() {
// UNROLL-FULL: %c2 = constant 2 : index
// UNROLL-FULL-NEXT: %c2_0 = constant 2 : index
// UNROLL-FULL-NEXT: affine.for %i0 = 0 to 100 {
// UNROLL-FULL-NEXT: affine.for %arg0 = 0 to 100 {
affine.for %i = 0 to 100 {
// UNROLL-FULL: %0 = affine.apply [[MAP0]](%c2_0)
// UNROLL-FULL-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
@ -121,16 +121,16 @@ func @loop_nest_strided() {
// UNROLL-FULL-LABEL: func @loop_nest_multiple_results() {
func @loop_nest_multiple_results() {
// UNROLL-FULL: %c0 = constant 0 : index
// UNROLL-FULL-NEXT: affine.for %i0 = 0 to 100 {
// UNROLL-FULL-NEXT: affine.for %arg0 = 0 to 100 {
affine.for %i = 0 to 100 {
// UNROLL-FULL: %0 = affine.apply [[MAP4]](%i0, %c0)
// UNROLL-FULL: %0 = affine.apply [[MAP4]](%arg0, %c0)
// UNROLL-FULL-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
// UNROLL-FULL-NEXT: %2 = affine.apply #map{{.*}}(%i0, %c0)
// UNROLL-FULL-NEXT: %2 = affine.apply #map{{.*}}(%arg0, %c0)
// UNROLL-FULL-NEXT: %3:2 = "fma"(%2, %0, %0) : (index, index, index) -> (index, index)
// UNROLL-FULL-NEXT: %4 = affine.apply #map{{.*}}(%c0)
// UNROLL-FULL-NEXT: %5 = affine.apply #map{{.*}}(%i0, %4)
// UNROLL-FULL-NEXT: %5 = affine.apply #map{{.*}}(%arg0, %4)
// UNROLL-FULL-NEXT: %6 = "addi32"(%5, %5) : (index, index) -> index
// UNROLL-FULL-NEXT: %7 = affine.apply #map{{.*}}(%i0, %4)
// UNROLL-FULL-NEXT: %7 = affine.apply #map{{.*}}(%arg0, %4)
// UNROLL-FULL-NEXT: %8:2 = "fma"(%7, %5, %5) : (index, index, index) -> (index, index)
affine.for %j = 0 to 2 step 1 {
%x = affine.apply (d0, d1) -> (d0 + 1) (%i, %j)
@ -149,9 +149,9 @@ func @loop_nest_seq_imperfect(%a : memref<128x128xf32>) {
// UNROLL-FULL: %c0 = constant 0 : index
// UNROLL-FULL-NEXT: %c128 = constant 128 : index
%c128 = constant 128 : index
// UNROLL-FULL: affine.for %i0 = 0 to 100 {
// UNROLL-FULL: affine.for %arg1 = 0 to 100 {
affine.for %i = 0 to 100 {
// UNROLL-FULL: %0 = "vld"(%i0) : (index) -> i32
// UNROLL-FULL: %0 = "vld"(%arg1) : (index) -> i32
%ld = "vld"(%i) : (index) -> i32
// UNROLL-FULL: %1 = affine.apply [[MAP0]](%c0)
// UNROLL-FULL-NEXT: %2 = "vmulf"(%c0, %1) : (index, index) -> index
@ -174,9 +174,9 @@ func @loop_nest_seq_imperfect(%a : memref<128x128xf32>) {
%y = "vmulf"(%j, %x) : (index, index) -> index
%z = "vaddf"(%y, %y) : (index, index) -> index
}
// UNROLL-FULL: %16 = "scale"(%c128, %i0) : (index, index) -> index
// UNROLL-FULL: %16 = "scale"(%c128, %arg1) : (index, index) -> index
%addr = "scale"(%c128, %i) : (index, index) -> index
// UNROLL-FULL: "vst"(%16, %i0) : (index, index) -> ()
// UNROLL-FULL: "vst"(%16, %arg1) : (index, index) -> ()
"vst"(%addr, %i) : (index, index) -> ()
} // UNROLL-FULL }
return // UNROLL-FULL: return
@ -205,7 +205,7 @@ func @loop_nest_seq_multiple() {
// UNROLL-FULL: %c99 = constant 99 : index
%k = constant 99 : index
// UNROLL-FULL: affine.for %i0 = 0 to 100 step 2 {
// UNROLL-FULL: affine.for %arg0 = 0 to 100 step 2 {
affine.for %m = 0 to 100 step 2 {
// UNROLL-FULL: %7 = affine.apply [[MAP0]](%c0)
// UNROLL-FULL-NEXT: %8 = affine.apply [[MAP6]](%c0)[%c99]
@ -242,13 +242,13 @@ func @loop_nest_unroll_full() {
// SHORT-LABEL: func @loop_nest_outer_unroll() {
func @loop_nest_outer_unroll() {
// SHORT: affine.for %i0 = 0 to 4 {
// SHORT-NEXT: %0 = affine.apply [[MAP0]](%i0)
// SHORT: affine.for %arg0 = 0 to 4 {
// SHORT-NEXT: %0 = affine.apply [[MAP0]](%arg0)
// SHORT-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
// SHORT-NEXT: }
// SHORT-NEXT: affine.for %i1 = 0 to 4 {
// SHORT-NEXT: %2 = affine.apply [[MAP0]](%i1)
// SHORT-NEXT: %3 = "addi32"(%2, %2) : (index, index) -> index
// SHORT-NEXT: affine.for %arg0 = 0 to 4 {
// SHORT-NEXT: %0 = affine.apply [[MAP0]](%arg0)
// SHORT-NEXT: %1 = "addi32"(%0, %0) : (index, index) -> index
// SHORT-NEXT: }
affine.for %i = 0 to 2 {
affine.for %j = 0 to 4 {
@ -275,9 +275,9 @@ func @loop_nest_seq_long() -> i32 {
%zero_idx = constant 0 : index
// CHECK: affine.for %i0 = 0 to 512
// CHECK: affine.for %arg0 = 0 to 512
affine.for %n0 = 0 to 512 {
// CHECK: affine.for %i1 = 0 to 8
// CHECK: affine.for %arg1 = 0 to 8
affine.for %n1 = 0 to 8 {
store %one, %A[%n0, %n1] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
store %two, %B[%n0, %n1] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
@ -287,11 +287,11 @@ func @loop_nest_seq_long() -> i32 {
affine.for %x = 0 to 2 {
affine.for %y = 0 to 2 {
// CHECK: affine.for %i2
affine.for %i2 = 0 to 8 {
// CHECK-NOT: affine.for %i3
// CHECK: affine.for
affine.for %arg2 = 0 to 8 {
// CHECK-NOT: affine.for
// CHECK: %{{[0-9]+}} = affine.apply
%b2 = "affine.apply" (%y, %i2) {map = (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
%b2 = "affine.apply" (%y, %arg2) {map = (d0, d1) -> (16*d0 + d1)} : (index, index) -> index
%z = load %B[%x, %b2] : memref<512 x 512 x i32, (d0, d1) -> (d0, d1), 2>
"op1"(%z) : (i32) -> ()
}
@ -318,9 +318,9 @@ func @loop_nest_seq_long() -> i32 {
// UNROLL-BY-4-LABEL: func @unroll_unit_stride_no_cleanup() {
func @unroll_unit_stride_no_cleanup() {
// UNROLL-BY-4: affine.for %i0 = 0 to 100 {
// UNROLL-BY-4: affine.for %arg0 = 0 to 100 {
affine.for %i = 0 to 100 {
// UNROLL-BY-4: for [[L1:%i[0-9]+]] = 0 to 8 step 4 {
// UNROLL-BY-4: for [[L1:%arg[0-9]+]] = 0 to 8 step 4 {
// UNROLL-BY-4-NEXT: %0 = "addi32"([[L1]], [[L1]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = "addi32"(%0, %0) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %2 = affine.apply #map{{[0-9]+}}([[L1]])
@ -338,7 +338,7 @@ func @unroll_unit_stride_no_cleanup() {
%y = "addi32"(%x, %x) : (i32, i32) -> i32
}
// empty loop
// UNROLL-BY-4: affine.for %i2 = 0 to 8 {
// UNROLL-BY-4: affine.for %arg1 = 0 to 8 {
affine.for %k = 0 to 8 {
}
}
@ -347,9 +347,9 @@ func @unroll_unit_stride_no_cleanup() {
// UNROLL-BY-4-LABEL: func @unroll_unit_stride_cleanup() {
func @unroll_unit_stride_cleanup() {
// UNROLL-BY-4: affine.for %i0 = 0 to 100 {
// UNROLL-BY-4: affine.for %arg0 = 0 to 100 {
affine.for %i = 0 to 100 {
// UNROLL-BY-4: for [[L1:%i[0-9]+]] = 0 to 8 step 4 {
// UNROLL-BY-4: for [[L1:%arg[0-9]+]] = 0 to 8 step 4 {
// UNROLL-BY-4-NEXT: %0 = "addi32"([[L1]], [[L1]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = "addi32"(%0, %0) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %2 = affine.apply #map{{[0-9]+}}([[L1]])
@ -362,9 +362,9 @@ func @unroll_unit_stride_cleanup() {
// UNROLL-BY-4-NEXT: %9 = "addi32"(%8, %8) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %10 = "addi32"(%9, %9) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: }
// UNROLL-BY-4-NEXT: for [[L2:%i[0-9]+]] = 8 to 10 {
// UNROLL-BY-4-NEXT: %11 = "addi32"([[L2]], [[L2]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %12 = "addi32"(%11, %11) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: for [[L2:%arg[0-9]+]] = 8 to 10 {
// UNROLL-BY-4-NEXT: %0 = "addi32"([[L2]], [[L2]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = "addi32"(%0, %0) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: }
affine.for %j = 0 to 10 {
%x = "addi32"(%j, %j) : (index, index) -> i32
@ -376,9 +376,9 @@ func @unroll_unit_stride_cleanup() {
// UNROLL-BY-4-LABEL: func @unroll_non_unit_stride_cleanup() {
func @unroll_non_unit_stride_cleanup() {
// UNROLL-BY-4: affine.for %i0 = 0 to 100 {
// UNROLL-BY-4: affine.for %arg0 = 0 to 100 {
affine.for %i = 0 to 100 {
// UNROLL-BY-4: for [[L1:%i[0-9]+]] = 2 to 42 step 20 {
// UNROLL-BY-4: for [[L1:%arg[0-9]+]] = 2 to 42 step 20 {
// UNROLL-BY-4-NEXT: %0 = "addi32"([[L1]], [[L1]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = "addi32"(%0, %0) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: %2 = affine.apply #map{{[0-9]+}}([[L1]])
@ -391,9 +391,9 @@ func @unroll_non_unit_stride_cleanup() {
// UNROLL-BY-4-NEXT: %9 = "addi32"(%8, %8) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %10 = "addi32"(%9, %9) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: }
// UNROLL-BY-4-NEXT: for [[L2:%i[0-9]+]] = 42 to 48 step 5 {
// UNROLL-BY-4-NEXT: %11 = "addi32"([[L2]], [[L2]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %12 = "addi32"(%11, %11) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: for [[L2:%arg[0-9]+]] = 42 to 48 step 5 {
// UNROLL-BY-4-NEXT: %0 = "addi32"([[L2]], [[L2]]) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = "addi32"(%0, %0) : (i32, i32) -> i32
// UNROLL-BY-4-NEXT: }
affine.for %j = 2 to 48 step 5 {
%x = "addi32"(%j, %j) : (index, index) -> i32
@ -408,7 +408,7 @@ func @unroll_non_unit_stride_cleanup() {
func @loop_nest_single_iteration_after_unroll(%N: index) {
// UNROLL-BY-4: %c0 = constant 0 : index
// UNROLL-BY-4: %c4 = constant 4 : index
// UNROLL-BY-4: affine.for %i0 = 0 to %arg0 {
// UNROLL-BY-4: affine.for %arg1 = 0 to %arg0 {
affine.for %i = 0 to %N {
// UNROLL-BY-4: %0 = "addi32"(%c0, %c0) : (index, index) -> i32
// UNROLL-BY-4-NEXT: %1 = affine.apply [[MAP0]](%c0)
@ -431,8 +431,8 @@ func @loop_nest_single_iteration_after_unroll(%N: index) {
// No cleanup will be generated here.
// UNROLL-BY-4-LABEL: func @loop_nest_operand1() {
func @loop_nest_operand1() {
// UNROLL-BY-4: affine.for %i0 = 0 to 100 step 2 {
// UNROLL-BY-4-NEXT: affine.for %i1 = 0 to #map{{[0-9]+}}(%i0) step 4
// UNROLL-BY-4: affine.for %arg0 = 0 to 100 step 2 {
// UNROLL-BY-4-NEXT: affine.for %arg1 = 0 to #map{{[0-9]+}}(%arg0) step 4
// UNROLL-BY-4-NEXT: %0 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %1 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %2 = "foo"() : () -> i32
@ -451,8 +451,8 @@ func @loop_nest_operand1() {
// No cleanup will be generated here.
// UNROLL-BY-4-LABEL: func @loop_nest_operand2() {
func @loop_nest_operand2() {
// UNROLL-BY-4: affine.for %i0 = 0 to 100 step 2 {
// UNROLL-BY-4-NEXT: affine.for %i1 = [[MAP11]](%i0) to #map{{[0-9]+}}(%i0) step 4 {
// UNROLL-BY-4: affine.for %arg0 = 0 to 100 step 2 {
// UNROLL-BY-4-NEXT: affine.for %arg1 = [[MAP11]](%arg0) to #map{{[0-9]+}}(%arg0) step 4 {
// UNROLL-BY-4-NEXT: %0 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %1 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %2 = "foo"() : () -> i32
@ -472,15 +472,15 @@ func @loop_nest_operand2() {
// factor. The cleanup loop happens to be a single iteration one and is promoted.
// UNROLL-BY-4-LABEL: func @loop_nest_operand3() {
func @loop_nest_operand3() {
// UNROLL-BY-4: affine.for %i0 = 0 to 100 step 2 {
// UNROLL-BY-4: affine.for %arg0 = 0 to 100 step 2 {
affine.for %i = 0 to 100 step 2 {
// UNROLL-BY-4: affine.for %i1 = [[MAP11]](%i0) to #map{{[0-9]+}}(%i0) step 4 {
// UNROLL-BY-4-NEXT: %0 = "foo"() : () -> i32
// UNROLL-BY-4: affine.for %arg1 = [[MAP11]](%arg0) to #map{{[0-9]+}}(%arg0) step 4 {
// UNROLL-BY-4-NEXT: %1 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %2 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %3 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: }
// UNROLL-BY-4-NEXT: %4 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: }
// UNROLL-BY-4-NEXT: %0 = "foo"() : () -> i32
affine.for %j = (d0) -> (d0) (%i) to (d0) -> (d0 + 9) (%i) {
%x = "foo"() : () -> i32
}
@ -490,17 +490,17 @@ func @loop_nest_operand3() {
// UNROLL-BY-4-LABEL: func @loop_nest_symbolic_bound(%arg0: index) {
func @loop_nest_symbolic_bound(%N : index) {
// UNROLL-BY-4: affine.for %i0 = 0 to 100 {
// UNROLL-BY-4: affine.for %arg1 = 0 to 100 {
affine.for %i = 0 to 100 {
// UNROLL-BY-4: affine.for %i1 = 0 to #map{{[0-9]+}}()[%arg0] step 4 {
// UNROLL-BY-4: affine.for %arg2 = 0 to #map{{[0-9]+}}()[%arg0] step 4 {
// UNROLL-BY-4: %0 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %1 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %2 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: %3 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: }
// A cleanup loop will be be generated here.
// UNROLL-BY-4-NEXT: affine.for %i2 = #map{{[0-9]+}}()[%arg0] to %arg0 {
// UNROLL-BY-4-NEXT: %4 = "foo"() : () -> i32
// UNROLL-BY-4-NEXT: affine.for %arg2 = #map{{[0-9]+}}()[%arg0] to %arg0 {
// UNROLL-BY-4-NEXT: %0 = "foo"() : () -> i32
// UNROLL-BY-4_NEXT: }
affine.for %j = 0 to %N {
%x = "foo"() : () -> i32
@ -516,13 +516,13 @@ func @loop_nest_symbolic_and_min_upper_bound(%M : index, %N : index, %K : index)
}
return
}
// CHECK-NEXT: affine.for %i0 = %arg0 to min [[MAP_TRIP_COUNT_MULTIPLE_FOUR]]()[%arg0, %arg1, %arg2] step 4 {
// CHECK-NEXT: affine.for %arg0 = %arg0 to min [[MAP_TRIP_COUNT_MULTIPLE_FOUR]]()[%arg0, %arg1, %arg2] step 4 {
// CHECK-NEXT: "foo"() : () -> ()
// CHECK-NEXT: "foo"() : () -> ()
// CHECK-NEXT: "foo"() : () -> ()
// CHECK-NEXT: "foo"() : () -> ()
// CHECK-NEXT: }
// CHECK-NEXT: affine.for %i1 = max [[MAP_TRIP_COUNT_MULTIPLE_FOUR]]()[%arg0, %arg1, %arg2] to min #map28()[%arg1, %arg2] {
// CHECK-NEXT: affine.for %arg1 = max [[MAP_TRIP_COUNT_MULTIPLE_FOUR]]()[%arg0, %arg1, %arg2] to min #map28()[%arg1, %arg2] {
// CHECK-NEXT: "foo"() : () -> ()
// CHECK-NEXT: }
// CHECK-NEXT: return
@ -538,7 +538,7 @@ func @loop_nest_non_trivial_multiple_unroll_factor(%M : index, %N : index) {
}
return
}
// UNROLL-BY-4: affine.for %i0 = 0 to min
// UNROLL-BY-4: affine.for %arg2 = 0 to min
// UNROLL-BY-4-NOT: for
// UNROLL-BY-4: return
@ -548,7 +548,7 @@ func @loop_nest_non_trivial_multiple_unroll_factor_2(%M : index, %N : index) {
affine.for %i = 0 to min ()[s0, s1] -> (4 * s0, s1, 1024)()[%N, %K] {
"foo"() : () -> ()
}
// UNROLL-BY-4: affine.for %i0 = 0 to min
// UNROLL-BY-4: affine.for %arg2 = 0 to min
// UNROLL-BY-4-NEXT: "foo"
// UNROLL-BY-4-NEXT: "foo"
// UNROLL-BY-4-NEXT: "foo"