22 changes: 11 additions & 11 deletions mlir/test/Conversion/SCFToGPU/parallel_loop.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ func @parallel_loop_bidy_bidx(%arg0 : index, %arg1 : index, %arg2 : index,
scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
step (%arg4, %step) {
%val = load %buf[%i0, %i1] : memref<?x?xf32>
memref.store %val, %res[%i1, %i0] : memref<?x?xf32>
store %val, %res[%i1, %i0] : memref<?x?xf32>
} { mapping = [{processor = 1, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}, {processor = 0, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}] }
return
}
Expand All @@ -29,7 +29,7 @@ func @parallel_loop_bidy_bidx(%arg0 : index, %arg1 : index, %arg2 : index,
// CHECK: [[VAL_23:%.*]] = affine.apply #[[$MAP1]]([[VAL_12]]){{\[}}[[VAL_4]], [[VAL_0]]]
// CHECK: [[VAL_24:%.*]] = affine.apply #[[$MAP1]]([[VAL_11]]){{\[}}[[VAL_7]], [[VAL_1]]]
// CHECK: [[VAL_25:%.*]] = load [[VAL_5]]{{\[}}[[VAL_23]], [[VAL_24]]] : memref<?x?xf32>
// CHECK: memref.store [[VAL_25]], [[VAL_6]]{{\[}}[[VAL_24]], [[VAL_23]]] : memref<?x?xf32>
// CHECK: store [[VAL_25]], [[VAL_6]]{{\[}}[[VAL_24]], [[VAL_23]]] : memref<?x?xf32>
// CHECK: gpu.terminator
// CHECK: }
// CHECK: return
Expand All @@ -54,7 +54,7 @@ func @parallel_loop_tiled(%arg0 : index, %arg1 : index, %arg2 : index,
%idx0 = addi %i0, %si0 : index
%idx1 = addi %i1, %si1 : index
%val = load %buf[%idx0, %idx1] : memref<?x?xf32>
memref.store %val, %res[%idx1, %idx0] : memref<?x?xf32>
store %val, %res[%idx1, %idx0] : memref<?x?xf32>
} { mapping = [
{processor = 4, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
{processor = 3, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
Expand Down Expand Up @@ -88,7 +88,7 @@ func @parallel_loop_tiled(%arg0 : index, %arg1 : index, %arg2 : index,
// CHECK: [[VAL_56:%.*]] = addi [[VAL_52]], [[VAL_54]] : index
// CHECK: [[VAL_57:%.*]] = addi [[VAL_53]], [[VAL_55]] : index
// CHECK: [[VAL_58:%.*]] = load [[VAL_30]]{{\[}}[[VAL_56]], [[VAL_57]]] : memref<?x?xf32>
// CHECK: memref.store [[VAL_58]], [[VAL_31]]{{\[}}[[VAL_57]], [[VAL_56]]] : memref<?x?xf32>
// CHECK: store [[VAL_58]], [[VAL_31]]{{\[}}[[VAL_57]], [[VAL_56]]] : memref<?x?xf32>
// CHECK: gpu.terminator
// CHECK: }
// CHECK: return
Expand All @@ -107,7 +107,7 @@ func @parallel_loop_bidy_seq(%arg0 : index, %arg1 : index, %arg2 : index,
scf.parallel (%i0, %i1) = (%arg0, %arg1) to (%arg2, %arg3)
step (%arg4, %step) {
%val = load %buf[%i0, %i1] : memref<?x?xf32>
memref.store %val, %res[%i1, %i0] : memref<?x?xf32>
store %val, %res[%i1, %i0] : memref<?x?xf32>
} { mapping = [
{processor = 1, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
{processor = 6, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
Expand All @@ -128,7 +128,7 @@ func @parallel_loop_bidy_seq(%arg0 : index, %arg1 : index, %arg2 : index,
// CHECK: [[VAL_81:%.*]] = affine.apply #[[$MAP1]]([[VAL_70]]){{\[}}[[VAL_63]], [[VAL_59]]]
// CHECK: scf.for [[VAL_82:%.*]] = [[VAL_60]] to [[VAL_62]] step [[VAL_66]] {
// CHECK: [[VAL_83:%.*]] = load [[VAL_64]]{{\[}}[[VAL_81]], [[VAL_82]]] : memref<?x?xf32>
// CHECK: memref.store [[VAL_83]], [[VAL_65]]{{\[}}[[VAL_82]], [[VAL_81]]] : memref<?x?xf32>
// CHECK: store [[VAL_83]], [[VAL_65]]{{\[}}[[VAL_82]], [[VAL_81]]] : memref<?x?xf32>
// CHECK: }
// CHECK: gpu.terminator
// CHECK: }
Expand All @@ -154,7 +154,7 @@ func @parallel_loop_tiled_seq(%arg0 : index, %arg1 : index, %arg2 : index,
%idx0 = addi %i0, %si0 : index
%idx1 = addi %i1, %si1 : index
%val = load %buf[%idx0, %idx1] : memref<?x?xf32>
memref.store %val, %res[%idx1, %idx0] : memref<?x?xf32>
store %val, %res[%idx1, %idx0] : memref<?x?xf32>
} { mapping = [
{processor = 4, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
{processor = 6, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
Expand Down Expand Up @@ -186,7 +186,7 @@ func @parallel_loop_tiled_seq(%arg0 : index, %arg1 : index, %arg2 : index,
// CHECK: [[VAL_112:%.*]] = addi [[VAL_108]], [[VAL_110]] : index
// CHECK: [[VAL_113:%.*]] = addi [[VAL_109]], [[VAL_111]] : index
// CHECK: [[VAL_114:%.*]] = load [[VAL_88]]{{\[}}[[VAL_112]], [[VAL_113]]] : memref<?x?xf32>
// CHECK: memref.store [[VAL_114]], [[VAL_89]]{{\[}}[[VAL_113]], [[VAL_112]]] : memref<?x?xf32>
// CHECK: store [[VAL_114]], [[VAL_89]]{{\[}}[[VAL_113]], [[VAL_112]]] : memref<?x?xf32>
// CHECK: }
// CHECK: }
// CHECK: gpu.terminator
Expand Down Expand Up @@ -232,7 +232,7 @@ module {
%18 = load %11[%arg5, %arg6] : memref<?x?xf32, #map3>
%19 = load %16[%arg5, %arg6] : memref<?x?xf32, #map3>
%20 = addf %17, %18 : f32
memref.store %20, %16[%arg5, %arg6] : memref<?x?xf32, #map3>
store %20, %16[%arg5, %arg6] : memref<?x?xf32, #map3>
scf.yield
} {mapping = [{bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 3 : i64}, {bound = affine_map<(d0) -> (d0)>, map = affine_map<(d0) -> (d0)>, processor = 4 : i64}]}
scf.yield
Expand Down Expand Up @@ -293,7 +293,7 @@ module {
// CHECK: [[VAL_50:%.*]] = load [[VAL_39]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
// CHECK: [[VAL_51:%.*]] = load [[VAL_44]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
// CHECK: [[VAL_52:%.*]] = addf [[VAL_49]], [[VAL_50]] : f32
// CHECK: memref.store [[VAL_52]], [[VAL_44]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
// CHECK: store [[VAL_52]], [[VAL_44]]{{\[}}[[VAL_45]], [[VAL_47]]] : memref<?x?xf32, #[[$MAP5]]>
// CHECK: }
// CHECK: }
// CHECK: gpu.terminator
Expand Down Expand Up @@ -354,7 +354,7 @@ func @parallel_loop_loop_variant_bound(%arg0 : index, %arg1 : index, %arg2 : ind
%idx0 = addi %i0, %si0 : index
%idx1 = addi %i1, %si1 : index
%val = load %buf[%idx0, %idx1] : memref<?x?xf32>
memref.store %val, %res[%idx1, %idx0] : memref<?x?xf32>
store %val, %res[%idx1, %idx0] : memref<?x?xf32>
} { mapping = [
{processor = 4, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>},
{processor = 6, map = affine_map<(d0) -> (d0)>, bound = affine_map<(d0) -> (d0)>}
Expand Down
6 changes: 3 additions & 3 deletions mlir/test/Conversion/SCFToGPU/step_one.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -67,9 +67,9 @@ func @step_1(%A : memref<?x?x?x?xf32>, %B : 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: memref.store {{.*}}, %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
// CHECK-22-NEXT: memref.store {{.*}}, %{{.*}}[%[[i]], %[[j]], %[[ii]], %[[jj]]] : memref<?x?x?x?xf32>
memref.store %0, %B[%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.terminator
// CHECK-22: gpu.terminator
Expand Down
4 changes: 2 additions & 2 deletions mlir/test/Conversion/SCFToGPU/step_positive.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,8 +20,8 @@ func @step_var(%A : memref<?x?xf32>, %B : memref<?x?xf32>) {

// CHECK: {{.*}} = load %{{.*}}[%[[i]], %[[j]]] : memref<?x?xf32>
%0 = load %A[%i, %j] : memref<?x?xf32>
// CHECK: memref.store {{.*}}, %{{.*}}[%[[i]], %[[j]]] : memref<?x?xf32>
memref.store %0, %B[%i, %j] : memref<?x?xf32>
// CHECK: store {{.*}}, %{{.*}}[%[[i]], %[[j]]] : memref<?x?xf32>
store %0, %B[%i, %j] : memref<?x?xf32>
}
}
return
Expand Down
6 changes: 3 additions & 3 deletions mlir/test/Conversion/SCFToSPIRV/for.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,7 +37,7 @@ func @loop_kernel(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) {
// CHECK: }
scf.for %arg4 = %lb to %ub step %step {
%1 = load %arg2[%arg4] : memref<10xf32>
memref.store %1, %arg3[%arg4] : memref<10xf32>
store %1, %arg3[%arg4] : memref<10xf32>
}
return
}
Expand Down Expand Up @@ -78,8 +78,8 @@ func @loop_yield(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>) {
// CHECK-DAG: %[[OUT2:.*]] = spv.Load "Function" %[[VAR2]] : f32
// CHECK: spv.Store "StorageBuffer" {{%.*}}, %[[OUT1]] : f32
// CHECK: spv.Store "StorageBuffer" {{%.*}}, %[[OUT2]] : f32
memref.store %result#0, %arg3[%lb] : memref<10xf32>
memref.store %result#1, %arg3[%ub] : memref<10xf32>
store %result#0, %arg3[%lb] : memref<10xf32>
store %result#1, %arg3[%ub] : memref<10xf32>
return
}

Expand Down
16 changes: 8 additions & 8 deletions mlir/test/Conversion/SCFToSPIRV/if.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,7 @@ func @kernel_simple_selection(%arg2 : memref<10xf32>, %arg3 : i1) {
// CHECK-NEXT: spv.Return

scf.if %arg3 {
memref.store %value, %arg2[%i] : memref<10xf32>
store %value, %arg2[%i] : memref<10xf32>
}
return
}
Expand Down Expand Up @@ -62,18 +62,18 @@ func @kernel_nested_selection(%arg3 : memref<10xf32>, %arg4 : memref<10xf32>, %a
scf.if %arg5 {
scf.if %arg6 {
%value = load %arg3[%i] : memref<10xf32>
memref.store %value, %arg4[%i] : memref<10xf32>
store %value, %arg4[%i] : memref<10xf32>
} else {
%value = load %arg4[%i] : memref<10xf32>
memref.store %value, %arg3[%i] : memref<10xf32>
store %value, %arg3[%i] : memref<10xf32>
}
} else {
scf.if %arg6 {
%value = load %arg3[%j] : memref<10xf32>
memref.store %value, %arg4[%j] : memref<10xf32>
store %value, %arg4[%j] : memref<10xf32>
} else {
%value = load %arg4[%j] : memref<10xf32>
memref.store %value, %arg3[%j] : memref<10xf32>
store %value, %arg3[%j] : memref<10xf32>
}
}
return
Expand Down Expand Up @@ -116,8 +116,8 @@ func @simple_if_yield(%arg2 : memref<10xf32>, %arg3 : i1) {
}
%i = constant 0 : index
%j = constant 1 : index
memref.store %0#0, %arg2[%i] : memref<10xf32>
memref.store %0#1, %arg2[%j] : memref<10xf32>
store %0#0, %arg2[%i] : memref<10xf32>
store %0#1, %arg2[%j] : memref<10xf32>
return
}

Expand Down Expand Up @@ -149,7 +149,7 @@ func @simple_if_yield_type_change(%arg2 : memref<10xf32>, %arg3 : memref<10xf32>
} else {
scf.yield %arg3 : memref<10xf32>
}
memref.store %value, %0[%i] : memref<10xf32>
store %value, %0[%i] : memref<10xf32>
return
}

Expand Down
6 changes: 3 additions & 3 deletions mlir/test/Conversion/SPIRVToLLVM/lower-host-to-llvm-calls.mlir
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,5 @@
// RUN: mlir-opt --lower-host-to-llvm %s | FileCheck %s

module attributes {gpu.container_module, spv.target_env = #spv.target_env<#spv.vce<v1.0, [Shader], [SPV_KHR_variable_pointers]>, {max_compute_workgroup_invocations = 128 : i32, max_compute_workgroup_size = dense<[128, 128, 64]> : vector<3xi32>}>} {

// CHECK: llvm.mlir.global linkonce @__spv__foo_bar_arg_0_descriptor_set0_binding0() : !llvm.struct<(array<6 x i32>)>
Expand All @@ -8,7 +8,7 @@ module attributes {gpu.container_module, spv.target_env = #spv.target_env<#spv.v
// CHECK: spv.module @__spv__foo
// CHECK: spv.globalVariable @bar_arg_0 bind(0, 0) : !spv.ptr<!spv.struct<(!spv.array<6 x i32, stride=4> [0])>, StorageBuffer>
// CHECK: spv.func @__spv__foo_bar

// CHECK: spv.EntryPoint "GLCompute" @__spv__foo_bar
// CHECK: spv.ExecutionMode @__spv__foo_bar "LocalSize", 1, 1, 1

Expand Down Expand Up @@ -38,7 +38,7 @@ module attributes {gpu.container_module, spv.target_env = #spv.target_env<#spv.v
}

func @main() {
%buffer = memref.alloc() : memref<6xi32>
%buffer = alloc() : memref<6xi32>
%one = constant 1 : index
gpu.launch_func @foo::@bar blocks in (%one, %one, %one)
threads in (%one, %one, %one) args(%buffer : memref<6xi32>)
Expand Down
4 changes: 2 additions & 2 deletions mlir/test/Conversion/StandardToLLVM/calling-convention.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -151,7 +151,7 @@ func @return_var_memref(%arg0: memref<4x3xf32>) -> memref<*xf32> {
// CHECK: %[[DESC_0:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
// CHECK: %[[DESC_1:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_0]][0]
// CHECK: %[[DESC_2:.*]] = llvm.insertvalue %[[MEMORY]], %[[DESC_1]][1]
%0 = memref.cast %arg0: memref<4x3xf32> to memref<*xf32>
%0 = memref_cast %arg0: memref<4x3xf32> to memref<*xf32>

// CHECK: %[[ONE:.*]] = llvm.mlir.constant(1 : index)
// CHECK: %[[TWO:.*]] = llvm.mlir.constant(2 : index)
Expand Down Expand Up @@ -213,7 +213,7 @@ func @return_two_var_memref(%arg0: memref<4x3xf32>) -> (memref<*xf32>, memref<*x
// CHECK: %[[DESC_0:.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
// CHECK: %[[DESC_1:.*]] = llvm.insertvalue %{{.*}}, %[[DESC_0]][0]
// CHECK: %[[DESC_2:.*]] = llvm.insertvalue %[[MEMORY]], %[[DESC_1]][1]
%0 = memref.cast %arg0 : memref<4x3xf32> to memref<*xf32>
%0 = memref_cast %arg0 : memref<4x3xf32> to memref<*xf32>

// Only check that we allocate the memory for each operand of the "return"
// separately, even if both operands are the same value. The calling
Expand Down
54 changes: 27 additions & 27 deletions mlir/test/Conversion/StandardToLLVM/convert-dynamic-memref-ops.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,7 +48,7 @@ func @mixed_alloc(%arg0: index, %arg1: index) -> memref<?x42x?xf32> {
// CHECK-NEXT: llvm.insertvalue %[[st0]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
%0 = memref.alloc(%arg0, %arg1) : memref<?x42x?xf32>
%0 = alloc(%arg0, %arg1) : memref<?x42x?xf32>
// CHECK-NEXT: llvm.return %{{.*}} : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
return %0 : memref<?x42x?xf32>
}
Expand All @@ -58,7 +58,7 @@ func @mixed_dealloc(%arg0: memref<?x42x?xf32>) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
// CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
memref.dealloc %arg0 : memref<?x42x?xf32>
dealloc %arg0 : memref<?x42x?xf32>
// CHECK-NEXT: llvm.return
return
}
Expand All @@ -82,7 +82,7 @@ func @dynamic_alloc(%arg0: index, %arg1: index) -> memref<?x?xf32> {
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[one]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
%0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
%0 = alloc(%arg0, %arg1) : memref<?x?xf32>
// CHECK-NEXT: llvm.return %{{.*}} : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
return %0 : memref<?x?xf32>
}
Expand All @@ -107,7 +107,7 @@ func @dynamic_alloca(%arg0: index, %arg1: index) -> memref<?x?xf32> {
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[N]], %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: llvm.insertvalue %[[st1]], %{{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
%0 = memref.alloca(%arg0, %arg1) : memref<?x?xf32>
%0 = alloca(%arg0, %arg1) : memref<?x?xf32>

// Test with explicitly specified alignment. llvm.alloca takes care of the
// alignment. The same pointer is thus used for allocation and aligned
Expand All @@ -116,7 +116,7 @@ func @dynamic_alloca(%arg0: index, %arg1: index) -> memref<?x?xf32> {
// CHECK: %[[desc:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[desc1:.*]] = llvm.insertvalue %[[alloca_aligned]], %[[desc]][0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[alloca_aligned]], %[[desc1]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
memref.alloca(%arg0, %arg1) {alignment = 32} : memref<?x?xf32>
alloca(%arg0, %arg1) {alignment = 32} : memref<?x?xf32>
return %0 : memref<?x?xf32>
}

Expand All @@ -125,7 +125,7 @@ func @dynamic_dealloc(%arg0: memref<?x?xf32>) {
// CHECK: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK-NEXT: %[[ptri8:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
// CHECK-NEXT: llvm.call @free(%[[ptri8]]) : (!llvm.ptr<i8>) -> ()
memref.dealloc %arg0 : memref<?x?xf32>
dealloc %arg0 : memref<?x?xf32>
return
}

Expand All @@ -142,23 +142,23 @@ func @stdlib_aligned_alloc(%N : index) -> memref<32x18xf32> {
// ALIGNED-ALLOC-NEXT: %[[alignment:.*]] = llvm.mlir.constant(32 : index) : i64
// ALIGNED-ALLOC-NEXT: %[[allocated:.*]] = llvm.call @aligned_alloc(%[[alignment]], %[[bytes]]) : (i64, i64) -> !llvm.ptr<i8>
// ALIGNED-ALLOC-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<f32>
%0 = memref.alloc() {alignment = 32} : memref<32x18xf32>
%0 = alloc() {alignment = 32} : memref<32x18xf32>
// Do another alloc just to test that we have a unique declaration for
// aligned_alloc.
// ALIGNED-ALLOC: llvm.call @aligned_alloc
%1 = memref.alloc() {alignment = 64} : memref<4096xf32>
%1 = alloc() {alignment = 64} : memref<4096xf32>

// Alignment is to element type boundaries (minimum 16 bytes).
// ALIGNED-ALLOC: %[[c32:.*]] = llvm.mlir.constant(32 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c32]]
%2 = memref.alloc() : memref<4096xvector<8xf32>>
%2 = alloc() : memref<4096xvector<8xf32>>
// The minimum alignment is 16 bytes unless explicitly specified.
// ALIGNED-ALLOC: %[[c16:.*]] = llvm.mlir.constant(16 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c16]],
%3 = memref.alloc() : memref<4096xvector<2xf32>>
%3 = alloc() : memref<4096xvector<2xf32>>
// ALIGNED-ALLOC: %[[c8:.*]] = llvm.mlir.constant(8 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c8]],
%4 = memref.alloc() {alignment = 8} : memref<1024xvector<4xf32>>
%4 = alloc() {alignment = 8} : memref<1024xvector<4xf32>>
// Bump the memref allocation size if its size is not a multiple of alignment.
// ALIGNED-ALLOC: %[[c32:.*]] = llvm.mlir.constant(32 : index) : i64
// ALIGNED-ALLOC-NEXT: llvm.mlir.constant(1 : index) : i64
Expand All @@ -167,11 +167,11 @@ func @stdlib_aligned_alloc(%N : index) -> memref<32x18xf32> {
// ALIGNED-ALLOC-NEXT: llvm.urem
// ALIGNED-ALLOC-NEXT: %[[SIZE_ALIGNED:.*]] = llvm.sub
// ALIGNED-ALLOC-NEXT: llvm.call @aligned_alloc(%[[c32]], %[[SIZE_ALIGNED]])
%5 = memref.alloc() {alignment = 32} : memref<100xf32>
%5 = alloc() {alignment = 32} : memref<100xf32>
// Bump alignment to the next power of two if it isn't.
// ALIGNED-ALLOC: %[[c128:.*]] = llvm.mlir.constant(128 : index) : i64
// ALIGNED-ALLOC: llvm.call @aligned_alloc(%[[c128]]
%6 = memref.alloc(%N) : memref<?xvector<18xf32>>
%6 = alloc(%N) : memref<?xvector<18xf32>>
return %0 : memref<32x18xf32>
}

Expand Down Expand Up @@ -232,17 +232,17 @@ func @prefetch(%A : memref<?x?xf32>, %i : index, %j : index) {
// CHECK-NEXT: [[C3:%.*]] = llvm.mlir.constant(3 : i32) : i32
// CHECK-NEXT: [[C1_1:%.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK-NEXT: "llvm.intr.prefetch"(%[[addr]], [[C1]], [[C3]], [[C1_1]]) : (!llvm.ptr<f32>, i32, i32, i32) -> ()
memref.prefetch %A[%i, %j], write, locality<3>, data : memref<?x?xf32>
prefetch %A[%i, %j], write, locality<3>, data : memref<?x?xf32>
// CHECK: [[C0:%.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: [[C0_1:%.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: [[C1_2:%.*]] = llvm.mlir.constant(1 : i32) : i32
// CHECK: "llvm.intr.prefetch"(%{{.*}}, [[C0]], [[C0_1]], [[C1_2]]) : (!llvm.ptr<f32>, i32, i32, i32) -> ()
memref.prefetch %A[%i, %j], read, locality<0>, data : memref<?x?xf32>
prefetch %A[%i, %j], read, locality<0>, data : memref<?x?xf32>
// CHECK: [[C0_2:%.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: [[C2:%.*]] = llvm.mlir.constant(2 : i32) : i32
// CHECK: [[C0_3:%.*]] = llvm.mlir.constant(0 : i32) : i32
// CHECK: "llvm.intr.prefetch"(%{{.*}}, [[C0_2]], [[C2]], [[C0_3]]) : (!llvm.ptr<f32>, i32, i32, i32) -> ()
memref.prefetch %A[%i, %j], read, locality<2>, instr : memref<?x?xf32>
prefetch %A[%i, %j], read, locality<2>, instr : memref<?x?xf32>
return
}

Expand All @@ -263,7 +263,7 @@ func @dynamic_store(%dynamic : memref<?x?xf32>, %i : index, %j : index, %val : f
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
// CHECK-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<f32>
memref.store %val, %dynamic[%i, %j] : memref<?x?xf32>
store %val, %dynamic[%i, %j] : memref<?x?xf32>
return
}

Expand All @@ -284,56 +284,56 @@ func @mixed_store(%mixed : memref<42x?xf32>, %i : index, %j : index, %val : f32)
// CHECK-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// CHECK-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
// CHECK-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<f32>
memref.store %val, %mixed[%i, %j] : memref<42x?xf32>
store %val, %mixed[%i, %j] : memref<42x?xf32>
return
}

// CHECK-LABEL: func @memref_cast_static_to_dynamic
func @memref_cast_static_to_dynamic(%static : memref<10x42xf32>) {
// CHECK-NOT: llvm.bitcast
%0 = memref.cast %static : memref<10x42xf32> to memref<?x?xf32>
%0 = memref_cast %static : memref<10x42xf32> to memref<?x?xf32>
return
}

// CHECK-LABEL: func @memref_cast_static_to_mixed
func @memref_cast_static_to_mixed(%static : memref<10x42xf32>) {
// CHECK-NOT: llvm.bitcast
%0 = memref.cast %static : memref<10x42xf32> to memref<?x42xf32>
%0 = memref_cast %static : memref<10x42xf32> to memref<?x42xf32>
return
}

// CHECK-LABEL: func @memref_cast_dynamic_to_static
func @memref_cast_dynamic_to_static(%dynamic : memref<?x?xf32>) {
// CHECK-NOT: llvm.bitcast
%0 = memref.cast %dynamic : memref<?x?xf32> to memref<10x12xf32>
%0 = memref_cast %dynamic : memref<?x?xf32> to memref<10x12xf32>
return
}

// CHECK-LABEL: func @memref_cast_dynamic_to_mixed
func @memref_cast_dynamic_to_mixed(%dynamic : memref<?x?xf32>) {
// CHECK-NOT: llvm.bitcast
%0 = memref.cast %dynamic : memref<?x?xf32> to memref<?x12xf32>
%0 = memref_cast %dynamic : memref<?x?xf32> to memref<?x12xf32>
return
}

// CHECK-LABEL: func @memref_cast_mixed_to_dynamic
func @memref_cast_mixed_to_dynamic(%mixed : memref<42x?xf32>) {
// CHECK-NOT: llvm.bitcast
%0 = memref.cast %mixed : memref<42x?xf32> to memref<?x?xf32>
%0 = memref_cast %mixed : memref<42x?xf32> to memref<?x?xf32>
return
}

// CHECK-LABEL: func @memref_cast_mixed_to_static
func @memref_cast_mixed_to_static(%mixed : memref<42x?xf32>) {
// CHECK-NOT: llvm.bitcast
%0 = memref.cast %mixed : memref<42x?xf32> to memref<42x1xf32>
%0 = memref_cast %mixed : memref<42x?xf32> to memref<42x1xf32>
return
}

// CHECK-LABEL: func @memref_cast_mixed_to_mixed
func @memref_cast_mixed_to_mixed(%mixed : memref<42x?xf32>) {
// CHECK-NOT: llvm.bitcast
%0 = memref.cast %mixed : memref<42x?xf32> to memref<?x1xf32>
%0 = memref_cast %mixed : memref<42x?xf32> to memref<?x1xf32>
return
}

Expand All @@ -347,15 +347,15 @@ func @memref_cast_ranked_to_unranked(%arg : memref<42x2x?xf32>) {
// CHECK : llvm.mlir.undef : !llvm.struct<(i64, ptr<i8>)>
// CHECK-DAG: llvm.insertvalue %[[r]], %{{.*}}[0] : !llvm.struct<(i64, ptr<i8>)>
// CHECK-DAG: llvm.insertvalue %[[p2]], %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
%0 = memref.cast %arg : memref<42x2x?xf32> to memref<*xf32>
%0 = memref_cast %arg : memref<42x2x?xf32> to memref<*xf32>
return
}

// CHECK-LABEL: func @memref_cast_unranked_to_ranked
func @memref_cast_unranked_to_ranked(%arg : memref<*xf32>) {
// CHECK: %[[p:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(i64, ptr<i8>)>
// CHECK-NEXT: llvm.bitcast %[[p]] : !llvm.ptr<i8> to !llvm.ptr<struct<(ptr<f32>, ptr<f32>, i64, array<4 x i64>, array<4 x i64>)>>
%0 = memref.cast %arg : memref<*xf32> to memref<?x?x10x2xf32>
%0 = memref_cast %arg : memref<*xf32> to memref<?x?x10x2xf32>
return
}

Expand Down
18 changes: 9 additions & 9 deletions mlir/test/Conversion/StandardToLLVM/convert-static-memref-ops.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -93,7 +93,7 @@ func @zero_d_alloc() -> memref<f32> {
// BAREPTR-NEXT: llvm.insertvalue %[[ptr]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
// BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// BAREPTR-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
%0 = memref.alloc() : memref<f32>
%0 = alloc() : memref<f32>
return %0 : memref<f32>
}

Expand All @@ -109,7 +109,7 @@ func @zero_d_dealloc(%arg0: memref<f32>) {
// BAREPTR: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
// BAREPTR-NEXT: %[[bc:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
// BAREPTR-NEXT: llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
memref.dealloc %arg0 : memref<f32>
dealloc %arg0 : memref<f32>
return
}

Expand Down Expand Up @@ -161,7 +161,7 @@ func @aligned_1d_alloc() -> memref<42xf32> {
// BAREPTR-NEXT: llvm.insertvalue %[[alignedBitCast]], %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
// BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
// BAREPTR-NEXT: llvm.insertvalue %[[c0]], %{{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1 x i64>, array<1 x i64>)>
%0 = memref.alloc() {alignment = 8} : memref<42xf32>
%0 = alloc() {alignment = 8} : memref<42xf32>
return %0 : memref<42xf32>
}

Expand All @@ -183,7 +183,7 @@ func @static_alloc() -> memref<32x18xf32> {
// BAREPTR-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
// BAREPTR-NEXT: %[[allocated:.*]] = llvm.call @malloc(%[[size_bytes]]) : (i64) -> !llvm.ptr<i8>
// BAREPTR-NEXT: llvm.bitcast %[[allocated]] : !llvm.ptr<i8> to !llvm.ptr<f32>
%0 = memref.alloc() : memref<32x18xf32>
%0 = alloc() : memref<32x18xf32>
return %0 : memref<32x18xf32>
}

Expand All @@ -199,7 +199,7 @@ func @static_alloca() -> memref<32x18xf32> {
// CHECK-NEXT: %[[gep:.*]] = llvm.getelementptr %[[null]][%[[num_elems]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
// CHECK-NEXT: %[[size_bytes:.*]] = llvm.ptrtoint %[[gep]] : !llvm.ptr<f32> to i64
// CHECK-NEXT: %[[allocated:.*]] = llvm.alloca %[[size_bytes]] x f32 : (i64) -> !llvm.ptr<f32>
%0 = memref.alloca() : memref<32x18xf32>
%0 = alloca() : memref<32x18xf32>

// Test with explicitly specified alignment. llvm.alloca takes care of the
// alignment. The same pointer is thus used for allocation and aligned
Expand All @@ -208,7 +208,7 @@ func @static_alloca() -> memref<32x18xf32> {
// CHECK: %[[desc:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[desc1:.*]] = llvm.insertvalue %[[alloca_aligned]], %[[desc]][0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[alloca_aligned]], %[[desc1]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
memref.alloca() {alignment = 32} : memref<32x18xf32>
alloca() {alignment = 32} : memref<32x18xf32>
return %0 : memref<32x18xf32>
}

Expand All @@ -224,7 +224,7 @@ func @static_dealloc(%static: memref<10x8xf32>) {
// BAREPTR: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// BAREPTR-NEXT: %[[bc:.*]] = llvm.bitcast %[[ptr]] : !llvm.ptr<f32> to !llvm.ptr<i8>
// BAREPTR-NEXT: llvm.call @free(%[[bc]]) : (!llvm.ptr<i8>) -> ()
memref.dealloc %static : memref<10x8xf32>
dealloc %static : memref<10x8xf32>
return
}

Expand Down Expand Up @@ -280,7 +280,7 @@ func @zero_d_store(%arg0: memref<f32>, %arg1: f32) {

// BAREPTR: %[[ptr:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
// BAREPTR-NEXT: llvm.store %[[val]], %[[ptr]] : !llvm.ptr<f32>
memref.store %arg1, %arg0[] : memref<f32>
store %arg1, %arg0[] : memref<f32>
return
}

Expand Down Expand Up @@ -314,7 +314,7 @@ func @static_store(%static : memref<10x42xf32>, %i : index, %j : index, %val : f
// BAREPTR-NEXT: %[[off1:.*]] = llvm.add %[[offI]], %[[J]] : i64
// BAREPTR-NEXT: %[[addr:.*]] = llvm.getelementptr %[[ptr]][%[[off1]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
// BAREPTR-NEXT: llvm.store %{{.*}}, %[[addr]] : !llvm.ptr<f32>
memref.store %val, %static[%i, %j] : memref<10x42xf32>
store %val, %static[%i, %j] : memref<10x42xf32>
return
}

Expand Down
12 changes: 6 additions & 6 deletions mlir/test/Conversion/StandardToLLVM/convert-to-llvmir.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -786,7 +786,7 @@ func @splat(%a: vector<4xf32>, %b: f32) -> vector<4xf32> {
func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
// CHECK: llvm.mlir.constant(2048 : index) : i64
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)>
%0 = memref.alloc() : memref<2048xi8>
%0 = alloc() : memref<2048xi8>

// Test two dynamic sizes.
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
Expand All @@ -802,7 +802,7 @@ func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
// CHECK: llvm.insertvalue %[[ARG0]], %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mul %{{.*}}, %[[ARG1]]
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
%1 = memref.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>
%1 = view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32>

// Test one dynamic size.
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
Expand All @@ -819,7 +819,7 @@ func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mul %{{.*}}, %[[ARG1]]
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
%3 = memref.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>
%3 = view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32>

// Test static sizes.
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
Expand All @@ -837,12 +837,12 @@ func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
%5 = memref.view %0[%arg2][] : memref<2048xi8> to memref<64x4xf32>
%5 = view %0[%arg2][] : memref<2048xi8> to memref<64x4xf32>

// Test view memory space.
// CHECK: llvm.mlir.constant(2048 : index) : i64
// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<i8, 4>, ptr<i8, 4>, i64, array<1 x i64>, array<1 x i64>)>
%6 = memref.alloc() : memref<2048xi8, 4>
%6 = alloc() : memref<2048xi8, 4>

// CHECK: llvm.mlir.undef : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: %[[BASE_PTR_4:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<i8, 4>, ptr<i8, 4>, i64, array<1 x i64>, array<1 x i64>)>
Expand All @@ -859,7 +859,7 @@ func @view(%arg0 : index, %arg1 : index, %arg2 : index) {
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.mlir.constant(4 : index) : i64
// CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<f32, 4>, ptr<f32, 4>, i64, array<2 x i64>, array<2 x i64>)>
%7 = memref.view %6[%arg2][] : memref<2048xi8, 4> to memref<64x4xf32, 4>
%7 = view %6[%arg2][] : memref<2048xi8, 4> to memref<64x4xf32, 4>

return
}
Expand Down
18 changes: 9 additions & 9 deletions mlir/test/Conversion/StandardToLLVM/standard-to-llvm.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@
// CHECK-LABEL: func @address_space(
// CHECK-SAME: !llvm.ptr<f32, 7>
func @address_space(%arg0 : memref<32xf32, affine_map<(d0) -> (d0)>, 7>) {
%0 = memref.alloc() : memref<32xf32, affine_map<(d0) -> (d0)>, 5>
%0 = alloc() : memref<32xf32, affine_map<(d0) -> (d0)>, 5>
%1 = constant 7 : index
// CHECK: llvm.load %{{.*}} : !llvm.ptr<f32, 5>
%2 = load %0[%1] : memref<32xf32, affine_map<(d0) -> (d0)>, 5>
Expand Down Expand Up @@ -122,25 +122,25 @@ func @assert_test_function(%arg : i1) {
// CHECK: llvm.extractvalue {{.*}}[3, 2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
// CHECK: llvm.insertvalue {{.*}}[3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
func @transpose(%arg0: memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]>) {
%0 = memref.transpose %arg0 (i, j, k) -> (k, i, j) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]> to memref<?x?x?xf32, affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d0 * s2 + d1)>>
%0 = transpose %arg0 (i, j, k) -> (k, i, j) : memref<?x?x?xf32, offset: ?, strides: [?, ?, 1]> to memref<?x?x?xf32, affine_map<(d0, d1, d2)[s0, s1, s2] -> (d2 * s1 + s0 + d0 * s2 + d1)>>
return
}

// -----

// CHECK: llvm.mlir.global external @gv0() : !llvm.array<2 x f32>
memref.global @gv0 : memref<2xf32> = uninitialized
global_memref @gv0 : memref<2xf32> = uninitialized

// CHECK: llvm.mlir.global private @gv1() : !llvm.array<2 x f32>
memref.global "private" @gv1 : memref<2xf32>
global_memref "private" @gv1 : memref<2xf32>

// CHECK: llvm.mlir.global external @gv2(dense<{{\[\[}}0.000000e+00, 1.000000e+00, 2.000000e+00], [3.000000e+00, 4.000000e+00, 5.000000e+00]]> : tensor<2x3xf32>) : !llvm.array<2 x array<3 x f32>>
memref.global @gv2 : memref<2x3xf32> = dense<[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]>
global_memref @gv2 : memref<2x3xf32> = dense<[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]>

// Test 1D memref.
// CHECK-LABEL: func @get_gv0_memref
func @get_gv0_memref() {
%0 = memref.get_global @gv0 : memref<2xf32>
%0 = get_global_memref @gv0 : memref<2xf32>
// CHECK: %[[DIM:.*]] = llvm.mlir.constant(2 : index) : i64
// CHECK: %[[STRIDE:.*]] = llvm.mlir.constant(1 : index) : i64
// CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv0 : !llvm.ptr<array<2 x f32>>
Expand Down Expand Up @@ -179,13 +179,13 @@ func @get_gv2_memref() {
// CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>
// CHECK: llvm.insertvalue %[[STRIDE1]], {{.*}}[4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)>

%0 = memref.get_global @gv2 : memref<2x3xf32>
%0 = get_global_memref @gv2 : memref<2x3xf32>
return
}

// Test scalar memref.
// CHECK: llvm.mlir.global external @gv3(1.000000e+00 : f32) : f32
memref.global @gv3 : memref<f32> = dense<1.0>
global_memref @gv3 : memref<f32> = dense<1.0>

// CHECK-LABEL: func @get_gv3_memref
func @get_gv3_memref() {
Expand All @@ -199,7 +199,7 @@ func @get_gv3_memref() {
// CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
// CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64
// CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
%0 = memref.get_global @gv3 : memref<f32>
%0 = get_global_memref @gv3 : memref<f32>
return
}

Expand Down
36 changes: 18 additions & 18 deletions mlir/test/Conversion/StandardToSPIRV/alloc.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,22 +10,22 @@ module attributes {
}
{
func @alloc_dealloc_workgroup_mem(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<4x5xf32, 3>
%0 = alloc() : memref<4x5xf32, 3>
%1 = load %0[%arg0, %arg1] : memref<4x5xf32, 3>
memref.store %1, %0[%arg0, %arg1] : memref<4x5xf32, 3>
memref.dealloc %0 : memref<4x5xf32, 3>
store %1, %0[%arg0, %arg1] : memref<4x5xf32, 3>
dealloc %0 : memref<4x5xf32, 3>
return
}
}
// CHECK: spv.globalVariable @[[VAR:.+]] : !spv.ptr<!spv.struct<(!spv.array<20 x f32, stride=4>)>, Workgroup>
// CHECK: func @alloc_dealloc_workgroup_mem
// CHECK-NOT: memref.alloc
// CHECK-NOT: alloc
// CHECK: %[[PTR:.+]] = spv.mlir.addressof @[[VAR]]
// CHECK: %[[LOADPTR:.+]] = spv.AccessChain %[[PTR]]
// CHECK: %[[VAL:.+]] = spv.Load "Workgroup" %[[LOADPTR]] : f32
// CHECK: %[[STOREPTR:.+]] = spv.AccessChain %[[PTR]]
// CHECK: spv.Store "Workgroup" %[[STOREPTR]], %[[VAL]] : f32
// CHECK-NOT: memref.dealloc
// CHECK-NOT: dealloc
// CHECK: spv.Return

// -----
Expand All @@ -36,10 +36,10 @@ module attributes {
}
{
func @alloc_dealloc_workgroup_mem(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<4x5xi16, 3>
%0 = alloc() : memref<4x5xi16, 3>
%1 = load %0[%arg0, %arg1] : memref<4x5xi16, 3>
memref.store %1, %0[%arg0, %arg1] : memref<4x5xi16, 3>
memref.dealloc %0 : memref<4x5xi16, 3>
store %1, %0[%arg0, %arg1] : memref<4x5xi16, 3>
dealloc %0 : memref<4x5xi16, 3>
return
}
}
Expand All @@ -65,8 +65,8 @@ module attributes {
}
{
func @two_allocs() {
%0 = memref.alloc() : memref<4x5xf32, 3>
%1 = memref.alloc() : memref<2x3xi32, 3>
%0 = alloc() : memref<4x5xf32, 3>
%1 = alloc() : memref<2x3xi32, 3>
return
}
}
Expand All @@ -86,8 +86,8 @@ module attributes {
}
{
func @two_allocs_vector() {
%0 = memref.alloc() : memref<4xvector<4xf32>, 3>
%1 = memref.alloc() : memref<2xvector<2xi32>, 3>
%0 = alloc() : memref<4xvector<4xf32>, 3>
%1 = alloc() : memref<2xvector<2xi32>, 3>
return
}
}
Expand All @@ -109,8 +109,8 @@ module attributes {
{
func @alloc_dealloc_dynamic_workgroup_mem(%arg0 : index) {
// expected-error @+2 {{unhandled allocation type}}
// expected-error @+1 {{'memref.alloc' op operand #0 must be index}}
%0 = memref.alloc(%arg0) : memref<4x?xf32, 3>
// expected-error @+1 {{'std.alloc' op operand #0 must be index}}
%0 = alloc(%arg0) : memref<4x?xf32, 3>
return
}
}
Expand All @@ -124,7 +124,7 @@ module attributes {
{
func @alloc_dealloc_mem() {
// expected-error @+1 {{unhandled allocation type}}
%0 = memref.alloc() : memref<4x5xf32>
%0 = alloc() : memref<4x5xf32>
return
}
}
Expand All @@ -139,8 +139,8 @@ module attributes {
{
func @alloc_dealloc_dynamic_workgroup_mem(%arg0 : memref<4x?xf32, 3>) {
// expected-error @+2 {{unhandled deallocation type}}
// expected-error @+1 {{'memref.dealloc' op operand #0 must be memref of any type values}}
memref.dealloc %arg0 : memref<4x?xf32, 3>
// expected-error @+1 {{'std.dealloc' op operand #0 must be memref of any type values}}
dealloc %arg0 : memref<4x?xf32, 3>
return
}
}
Expand All @@ -155,7 +155,7 @@ module attributes {
func @alloc_dealloc_mem(%arg0 : memref<4x5xf32>) {
// expected-error @+2 {{unhandled deallocation type}}
// expected-error @+1 {{op operand #0 must be memref of any type values}}
memref.dealloc %arg0 : memref<4x5xf32>
dealloc %arg0 : memref<4x5xf32>
return
}
}
8 changes: 4 additions & 4 deletions mlir/test/Conversion/StandardToSPIRV/legalization.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -41,10 +41,10 @@ func @fold_static_stride_subview_with_store(%arg0 : memref<12x32xf32>, %arg1 : i
// CHECK: [[INDEX1:%.*]] = addi [[ARG1]], [[STRIDE1]] : index
// CHECK: [[STRIDE2:%.*]] = muli [[ARG4]], [[C3]] : index
// CHECK: [[INDEX2:%.*]] = addi [[ARG2]], [[STRIDE2]] : index
// CHECK: memref.store [[ARG5]], [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}
// CHECK: store [[ARG5]], [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}
%0 = subview %arg0[%arg1, %arg2][4, 4][2, 3] :
memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [64, 3]>
memref.store %arg5, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [64, 3]>
store %arg5, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [64, 3]>
return
}

Expand All @@ -56,10 +56,10 @@ func @fold_dynamic_stride_subview_with_store(%arg0 : memref<12x32xf32>, %arg1 :
// CHECK: [[INDEX1:%.*]] = addi [[ARG1]], [[STRIDE1]] : index
// CHECK: [[STRIDE2:%.*]] = muli [[ARG4]], [[ARG6]] : index
// CHECK: [[INDEX2:%.*]] = addi [[ARG2]], [[STRIDE2]] : index
// CHECK: memref.store [[ARG7]], [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}
// CHECK: store [[ARG7]], [[ARG0]]{{\[}}[[INDEX1]], [[INDEX2]]{{\]}}
%0 = subview %arg0[%arg1, %arg2][4, 4][%arg5, %arg6] :
memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [?, ?]>
memref.store %arg7, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [?, ?]>
store %arg7, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [?, ?]>
return
}

Expand Down
16 changes: 8 additions & 8 deletions mlir/test/Conversion/StandardToSPIRV/std-ops-to-spirv.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -882,7 +882,7 @@ func @load_store_zero_rank_float(%arg0: memref<f32>, %arg1: memref<f32>) {
// CHECK-SAME: [[ZERO2]], [[ZERO2]]
// CHECK-SAME: ] :
// CHECK: spv.Store "StorageBuffer" %{{.*}} : f32
memref.store %0, %arg1[] : memref<f32>
store %0, %arg1[] : memref<f32>
return
}

Expand All @@ -901,7 +901,7 @@ func @load_store_zero_rank_int(%arg0: memref<i32>, %arg1: memref<i32>) {
// CHECK-SAME: [[ZERO2]], [[ZERO2]]
// CHECK-SAME: ] :
// CHECK: spv.Store "StorageBuffer" %{{.*}} : i32
memref.store %0, %arg1[] : memref<i32>
store %0, %arg1[] : memref<i32>
return
}

Expand Down Expand Up @@ -1000,7 +1000,7 @@ func @store_i8(%arg0: memref<i8>, %value: i8) {
// CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
// CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
// CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
memref.store %value, %arg0[] : memref<i8>
store %value, %arg0[] : memref<i8>
return
}

Expand All @@ -1026,7 +1026,7 @@ func @store_i16(%arg0: memref<10xi16>, %index: index, %value: i16) {
// CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
// CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
// CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
memref.store %value, %arg0[%index] : memref<10xi16>
store %value, %arg0[%index] : memref<10xi16>
return
}

Expand All @@ -1035,7 +1035,7 @@ func @store_i32(%arg0: memref<i32>, %value: i32) {
// CHECK: spv.Store
// CHECK-NOT: spv.AtomicAnd
// CHECK-NOT: spv.AtomicOr
memref.store %value, %arg0[] : memref<i32>
store %value, %arg0[] : memref<i32>
return
}

Expand All @@ -1044,7 +1044,7 @@ func @store_f32(%arg0: memref<f32>, %value: f32) {
// CHECK: spv.Store
// CHECK-NOT: spv.AtomicAnd
// CHECK-NOT: spv.AtomicOr
memref.store %value, %arg0[] : memref<f32>
store %value, %arg0[] : memref<f32>
return
}

Expand Down Expand Up @@ -1108,7 +1108,7 @@ func @store_i8(%arg0: memref<i8>, %value: i8) {
// CHECK: %[[PTR:.+]] = spv.AccessChain %[[ARG0]][%[[ZERO]], %[[ACCESS_IDX]]]
// CHECK: spv.AtomicAnd "Device" "AcquireRelease" %[[PTR]], %[[MASK]]
// CHECK: spv.AtomicOr "Device" "AcquireRelease" %[[PTR]], %[[STORE_VAL]]
memref.store %value, %arg0[] : memref<i8>
store %value, %arg0[] : memref<i8>
return
}

Expand All @@ -1117,7 +1117,7 @@ func @store_i16(%arg0: memref<10xi16>, %index: index, %value: i16) {
// CHECK: spv.Store
// CHECK-NOT: spv.AtomicAnd
// CHECK-NOT: spv.AtomicOr
memref.store %value, %arg0[%index] : memref<10xi16>
store %value, %arg0[%index] : memref<10xi16>
return
}

Expand Down
4 changes: 2 additions & 2 deletions mlir/test/Conversion/StandardToSPIRV/subview-to-spirv.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,11 +27,11 @@ func @fold_static_stride_subview
// CHECK: %[[T7:.*]] = addi %[[ARG1]], %[[T6]]
// CHECK: %[[T8:.*]] = muli %[[ARG4]], %[[ARG2]]
// CHECK: %[[T9:.*]] = addi %[[T8]], %[[C2]]
// CHECK: memref.store %[[STOREVAL]], %[[ARG0]][%[[T7]], %[[T9]]]
// CHECK: store %[[STOREVAL]], %[[ARG0]][%[[T7]], %[[T9]]]
%0 = subview %arg0[%arg1, 2][4, 4][3, %arg2] : memref<12x32xf32> to memref<4x4xf32, offset:?, strides: [96, ?]>
%1 = load %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [96, ?]>
%2 = math.sqrt %1 : f32
memref.store %2, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [96, ?]>
store %2, %0[%arg3, %arg4] : memref<4x4xf32, offset:?, strides: [96, ?]>
return
}

Expand Down
28 changes: 14 additions & 14 deletions mlir/test/Conversion/VectorToSCF/vector-to-loops.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@
// CHECK-LABEL: func @materialize_read_1d() {
func @materialize_read_1d() {
%f0 = constant 0.0: f32
%A = memref.alloc () : memref<7x42xf32>
%A = alloc () : memref<7x42xf32>
affine.for %i0 = 0 to 7 step 4 {
affine.for %i1 = 0 to 42 step 4 {
%f1 = vector.transfer_read %A[%i0, %i1], %f0 {permutation_map = affine_map<(d0, d1) -> (d0)>} : memref<7x42xf32>, vector<4xf32>
Expand Down Expand Up @@ -35,7 +35,7 @@ func @materialize_read_1d() {
// CHECK-LABEL: func @materialize_read_1d_partially_specialized
func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %dyn4 : index) {
%f0 = constant 0.0: f32
%A = memref.alloc (%dyn1, %dyn2, %dyn4) : memref<7x?x?x42x?xf32>
%A = alloc (%dyn1, %dyn2, %dyn4) : memref<7x?x?x42x?xf32>
affine.for %i0 = 0 to 7 {
affine.for %i1 = 0 to %dyn1 {
affine.for %i2 = 0 to %dyn2 {
Expand All @@ -52,7 +52,7 @@ func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %d
}
}
}
// CHECK: %[[tensor:[0-9]+]] = memref.alloc
// CHECK: %[[tensor:[0-9]+]] = alloc
// CHECK-NOT: {{.*}} dim %[[tensor]], %c0
// CHECK-NOT: {{.*}} dim %[[tensor]], %c3
return
Expand All @@ -65,13 +65,13 @@ func @materialize_read_1d_partially_specialized(%dyn1 : index, %dyn2 : index, %d
// CHECK-LABEL: func @materialize_read(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
%f0 = constant 0.0: f32
// CHECK-DAG: %[[ALLOC:.*]] = memref.alloca() : memref<5x4xvector<3xf32>>
// CHECK-DAG: %[[ALLOC:.*]] = alloca() : memref<5x4xvector<3xf32>>
// CHECK-DAG: %[[C0:.*]] = constant 0 : index
// CHECK-DAG: %[[C1:.*]] = constant 1 : index
// CHECK-DAG: %[[C3:.*]] = constant 3 : index
// CHECK-DAG: %[[C4:.*]] = constant 4 : index
// CHECK-DAG: %[[C5:.*]] = constant 5 : index
// CHECK: %{{.*}} = memref.alloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?x?xf32>
// CHECK: %{{.*}} = 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 %{{.*}} {
Expand Down Expand Up @@ -107,7 +107,7 @@ func @materialize_read(%M: index, %N: index, %O: index, %P: index) {
// Check that I0 + I4 (of size 3) read from first index load(L0, ...) and write into last index store(..., I4)
// Check that I3 + I6 (of size 5) read from last index load(..., L3) and write into first index store(I6, ...)
// Other dimensions are just accessed with I1, I2 resp.
%A = memref.alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
%A = alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
affine.for %i0 = 0 to %M step 3 {
affine.for %i1 = 0 to %N {
affine.for %i2 = 0 to %O {
Expand All @@ -129,14 +129,14 @@ func @materialize_read(%M: index, %N: index, %O: index, %P: index) {

// CHECK-LABEL:func @materialize_write(%{{.*}}: index, %{{.*}}: index, %{{.*}}: index, %{{.*}}: index) {
func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
// CHECK-DAG: %[[ALLOC:.*]] = memref.alloca() : memref<5x4xvector<3xf32>>
// CHECK-DAG: %[[ALLOC:.*]] = alloca() : memref<5x4xvector<3xf32>>
// CHECK-DAG: %{{.*}} = constant dense<1.000000e+00> : vector<5x4x3xf32>
// CHECK-DAG: %[[C0:.*]] = constant 0 : index
// CHECK-DAG: %[[C1:.*]] = constant 1 : index
// CHECK-DAG: %[[C3:.*]] = constant 3 : index
// CHECK-DAG: %[[C4:.*]] = constant 4 : index
// CHECK-DAG: %[[C5:.*]] = constant 5 : index
// CHECK: %{{.*}} = memref.alloc(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : memref<?x?x?x?xf32>
// CHECK: %{{.*}} = 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 %{{.*}} {
Expand Down Expand Up @@ -169,7 +169,7 @@ func @materialize_write(%M: index, %N: index, %O: index, %P: index) {
// Check that I1 + I5 (of size 4) read from second index load(..., I5, ...) and write into second index store(..., S1, ...)
// Check that I3 + I6 (of size 5) read from first index load(I6, ...) and write into last index store(..., S3)
// Other dimension is just accessed with I2.
%A = memref.alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
%A = alloc (%M, %N, %O, %P) : memref<?x?x?x?xf32, 0>
%f1 = constant dense<1.000000e+00> : vector<5x4x3xf32>
affine.for %i0 = 0 to %M step 3 {
affine.for %i1 = 0 to %N step 4 {
Expand Down Expand Up @@ -204,7 +204,7 @@ func @transfer_read_progressive(%A : memref<?x?xf32>, %base: index) -> vector<3x
%f7 = constant 7.0: f32

// CHECK-DAG: %[[splat:.*]] = constant dense<7.000000e+00> : vector<15xf32>
// CHECK-DAG: %[[alloc:.*]] = memref.alloca() : memref<3xvector<15xf32>>
// CHECK-DAG: %[[alloc:.*]] = alloca() : memref<3xvector<15xf32>>
// CHECK-DAG: %[[C0:.*]] = constant 0 : index
// CHECK-DAG: %[[dim:.*]] = dim %[[A]], %[[C0]] : memref<?x?xf32>
// CHECK: affine.for %[[I:.*]] = 0 to 3 {
Expand Down Expand Up @@ -277,7 +277,7 @@ func @transfer_read_progressive(%A : memref<?x?xf32>, %base: index) -> vector<3x
// FULL-UNROLL-SAME: %[[vec:[a-zA-Z0-9]+]]: vector<3x15xf32>
func @transfer_write_progressive(%A : memref<?x?xf32>, %base: index, %vec: vector<3x15xf32>) {
// CHECK: %[[C0:.*]] = constant 0 : index
// CHECK: %[[alloc:.*]] = memref.alloca() : memref<3xvector<15xf32>>
// CHECK: %[[alloc:.*]] = alloca() : memref<3xvector<15xf32>>
// CHECK: %[[vmemref:.*]] = vector.type_cast %[[alloc]] : memref<3xvector<15xf32>> to memref<vector<3x15xf32>>
// CHECK: store %[[vec]], %[[vmemref]][] : memref<vector<3x15xf32>>
// CHECK: %[[dim:.*]] = dim %[[A]], %[[C0]] : memref<?x?xf32>
Expand Down Expand Up @@ -331,7 +331,7 @@ func @transfer_write_progressive(%A : memref<?x?xf32>, %base: index, %vec: vecto
// FULL-UNROLL-SAME: %[[vec:[a-zA-Z0-9]+]]: vector<3x15xf32>
func @transfer_write_progressive_unmasked(%A : memref<?x?xf32>, %base: index, %vec: vector<3x15xf32>) {
// CHECK-NOT: scf.if
// CHECK-NEXT: %[[alloc:.*]] = memref.alloca() : memref<3xvector<15xf32>>
// CHECK-NEXT: %[[alloc:.*]] = alloca() : memref<3xvector<15xf32>>
// CHECK-NEXT: %[[vmemref:.*]] = vector.type_cast %[[alloc]] : memref<3xvector<15xf32>> to memref<vector<3x15xf32>>
// CHECK-NEXT: store %[[vec]], %[[vmemref]][] : memref<vector<3x15xf32>>
// CHECK-NEXT: affine.for %[[I:.*]] = 0 to 3 {
Expand Down Expand Up @@ -384,7 +384,7 @@ func @transfer_read_minor_identity(%A : memref<?x?x?x?xf32>) -> vector<3x3xf32>
// CHECK: %[[cst:.*]] = constant 0.000000e+00 : f32
// CHECK: %[[c2:.*]] = constant 2 : index
// CHECK: %[[cst0:.*]] = constant dense<0.000000e+00> : vector<3xf32>
// CHECK: %[[m:.*]] = memref.alloca() : memref<3xvector<3xf32>>
// CHECK: %[[m:.*]] = alloca() : memref<3xvector<3xf32>>
// CHECK: %[[d:.*]] = dim %[[A]], %[[c2]] : memref<?x?x?x?xf32>
// CHECK: affine.for %[[arg1:.*]] = 0 to 3 {
// CHECK: %[[cmp:.*]] = cmpi slt, %[[arg1]], %[[d]] : index
Expand Down Expand Up @@ -413,7 +413,7 @@ func @transfer_write_minor_identity(%A : vector<3x3xf32>, %B : memref<?x?x?x?xf3
// CHECK-SAME: %[[B:.*]]: memref<?x?x?x?xf32>)
// CHECK: %[[c0:.*]] = constant 0 : index
// CHECK: %[[c2:.*]] = constant 2 : index
// CHECK: %[[m:.*]] = memref.alloca() : memref<3xvector<3xf32>>
// CHECK: %[[m:.*]] = alloca() : memref<3xvector<3xf32>>
// CHECK: %[[cast:.*]] = vector.type_cast %[[m]] : memref<3xvector<3xf32>> to memref<vector<3x3xf32>>
// CHECK: store %[[A]], %[[cast]][] : memref<vector<3x3xf32>>
// CHECK: %[[d:.*]] = dim %[[B]], %[[c2]] : memref<?x?x?x?xf32>
Expand Down
8 changes: 4 additions & 4 deletions mlir/test/Dialect/Affine/SuperVectorize/vector_utils.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,12 +4,12 @@

func @vector_add_2d(%arg0: index, %arg1: index) -> f32 {
// Nothing should be matched in this first block.
// CHECK-NOT:matched: {{.*}} = memref.alloc{{.*}}
// CHECK-NOT:matched: {{.*}} = alloc{{.*}}
// CHECK-NOT:matched: {{.*}} = constant 0{{.*}}
// CHECK-NOT:matched: {{.*}} = constant 1{{.*}}
%0 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
%1 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
%2 = memref.alloc(%arg0, %arg1) : memref<?x?xf32>
%0 = alloc(%arg0, %arg1) : memref<?x?xf32>
%1 = alloc(%arg0, %arg1) : memref<?x?xf32>
%2 = alloc(%arg0, %arg1) : memref<?x?xf32>
%c0 = constant 0 : index
%cst = constant 1.000000e+00 : f32

Expand Down
8 changes: 4 additions & 4 deletions mlir/test/Dialect/Affine/SuperVectorize/vectorize_1d.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -92,9 +92,9 @@ func @vec1d_3(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {

// CHECK-LABEL: func @vector_add_2d
func @vector_add_2d(%M : index, %N : index) -> f32 {
%A = memref.alloc (%M, %N) : memref<?x?xf32, 0>
%B = memref.alloc (%M, %N) : memref<?x?xf32, 0>
%C = memref.alloc (%M, %N) : memref<?x?xf32, 0>
%A = alloc (%M, %N) : memref<?x?xf32, 0>
%B = alloc (%M, %N) : memref<?x?xf32, 0>
%C = alloc (%M, %N) : memref<?x?xf32, 0>
%f1 = constant 1.0 : f32
%f2 = constant 2.0 : f32
affine.for %i0 = 0 to %M {
Expand Down Expand Up @@ -309,7 +309,7 @@ func @vec_rejected_7(%A : memref<?x?xf32>, %B : memref<?x?x?xf32>) {

// CHECK: affine.for %{{.*}}{{[0-9]*}} = 0 to %{{[0-9]*}} {
affine.for %i16 = 0 to %M { // not vectorized, can't vectorize a vector load
%a16 = memref.alloc(%M) : memref<?xvector<2xf32>>
%a16 = alloc(%M) : memref<?xvector<2xf32>>
%l16 = affine.load %a16[%i16] : memref<?xvector<2xf32>>
}
return
Expand Down
6 changes: 3 additions & 3 deletions mlir/test/Dialect/Affine/SuperVectorize/vectorize_2d.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -47,9 +47,9 @@ func @vec2d(%A : memref<?x?x?xf32>) {
}

func @vector_add_2d(%M : index, %N : index) -> f32 {
%A = memref.alloc (%M, %N) : memref<?x?xf32, 0>
%B = memref.alloc (%M, %N) : memref<?x?xf32, 0>
%C = memref.alloc (%M, %N) : memref<?x?xf32, 0>
%A = alloc (%M, %N) : memref<?x?xf32, 0>
%B = alloc (%M, %N) : memref<?x?xf32, 0>
%C = alloc (%M, %N) : memref<?x?xf32, 0>
%f1 = constant 1.0 : f32
%f2 = constant 2.0 : f32
affine.for %i0 = 0 to %M {
Expand Down
52 changes: 26 additions & 26 deletions mlir/test/Dialect/Affine/affine-data-copy.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -49,7 +49,7 @@ func @matmul(%A: memref<4096x4096xf32>, %B: memref<4096x4096xf32>, %C: memref<40

// CHECK: affine.for %[[I:.*]] = 0 to 4096 step 128 {
// CHECK: affine.for %[[J:.*]] = 0 to 4096 step 128 {
// CHECK: [[BUFC:%[0-9]+]] = memref.alloc() : memref<128x128xf32>
// CHECK: [[BUFC:%[0-9]+]] = alloc() : memref<128x128xf32>
// The result matrix's copy gets hoisted out.
// Result matrix copy-in.
// CHECK: affine.for %[[II:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
Expand All @@ -61,7 +61,7 @@ func @matmul(%A: memref<4096x4096xf32>, %B: memref<4096x4096xf32>, %C: memref<40

// LHS matrix copy-in.
// CHECK: affine.for %[[K:.*]] = 0 to 4096 step 128 {
// CHECK: [[BUFA:%[0-9]+]] = memref.alloc() : memref<128x128xf32>
// CHECK: [[BUFA:%[0-9]+]] = alloc() : memref<128x128xf32>
// CHECK: affine.for %[[II:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
// CHECK: affine.for %[[KK:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
// CHECK: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<4096x4096xf32>
Expand All @@ -70,7 +70,7 @@ func @matmul(%A: memref<4096x4096xf32>, %B: memref<4096x4096xf32>, %C: memref<40
// CHECK: }

// RHS matrix copy-in.
// CHECK: [[BUFB:%[0-9]+]] = memref.alloc() : memref<128x128xf32>
// CHECK: [[BUFB:%[0-9]+]] = alloc() : memref<128x128xf32>
// CHECK: affine.for %[[KK:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
// CHECK: affine.for %[[JJ:.*]] = #[[$MAP_IDENTITY]](%{{.*}}) to #[[$MAP_PLUS_128]](%{{.*}}) {
// CHECK: affine.load %{{.*}}[%{{.*}}, %{{.*}}] : memref<4096x4096xf32>
Expand All @@ -91,8 +91,8 @@ func @matmul(%A: memref<4096x4096xf32>, %B: memref<4096x4096xf32>, %C: memref<40
// CHECK: }
// CHECK: }
// CHECK: }
// CHECK: memref.dealloc [[BUFB]] : memref<128x128xf32>
// CHECK: memref.dealloc [[BUFA]] : memref<128x128xf32>
// CHECK: dealloc [[BUFB]] : memref<128x128xf32>
// CHECK: dealloc [[BUFA]] : memref<128x128xf32>
// CHECK: }

// Result matrix copy out.
Expand All @@ -102,24 +102,24 @@ func @matmul(%A: memref<4096x4096xf32>, %B: memref<4096x4096xf32>, %C: memref<40
// CHECK: store %{{.*}}, %{{.*}}[%{{.*}}, %{{.*}}] : memref<4096x4096xf32>
// CHECK: }
// CHECK: }
// CHECK: memref.dealloc [[BUFC]] : memref<128x128xf32>
// CHECK: dealloc [[BUFC]] : memref<128x128xf32>
// CHECK: }
// CHECK: }

// Check that only one memref is copied when memref filter is used.

// FILTER: affine.for %{{.*}} = 0 to 4096 step 128 {
// FILTER: memref.alloc() : memref<128x4096xf32>
// FILTER-NOT: memref.alloc()
// FILTER: alloc() : memref<128x4096xf32>
// FILTER-NOT: alloc()
// FILTER: affine.for
// FILTER: affine.for %{{.*}} = 0 to 4096 {
// FILTER: affine.for %{{.*}} = 0 to 4096 step 128 {
// FILTER-NEXT: affine.for %{{.*}} = 0 to 4096 step 128 {
// FILTER-NEXT: affine.for %{{.*}} = #map{{.*}}(%{{.*}}) to #map{{.*}}(%{{.*}}) {
// FILTER-NEXT: affine.for %{{.*}} = #map{{.*}}(%{{.*}}) to #map{{.*}}(%{{.*}}) {
// FILTER-NEXT: affine.for %{{.*}} = #map{{.*}}(%{{.*}}) to #map{{.*}}(%{{.*}}) {
// FILTER: memref.dealloc %{{.*}} : memref<128x4096xf32>
// FILTER-NOT: memref.dealloc %{{.*}} : memref<128x4096xf32>
// FILTER: dealloc %{{.*}} : memref<128x4096xf32>
// FILTER-NOT: dealloc %{{.*}} : memref<128x4096xf32>

// -----

Expand All @@ -145,52 +145,52 @@ func @single_elt_buffers(%arg0: memref<1024x1024xf32>, %arg1: memref<1024x1024xf
}
// CHECK-SMALL: affine.for %arg{{.*}} = 0 to 1024 {
// CHECK-SMALL: affine.for %arg{{.*}} = 0 to 1024 {
// CHECK-SMALL: memref.alloc() : memref<1x1xf32>
// CHECK-SMALL: alloc() : memref<1x1xf32>
// CHECK-SMALL: affine.load %arg{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-SMALL: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-SMALL: affine.for %arg{{.*}} = 0 to 1024 {
// CHECK-SMALL: memref.alloc() : memref<1x1xf32>
// CHECK-SMALL: alloc() : memref<1x1xf32>
// CHECK-SMALL: affine.load %arg{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-SMALL: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-SMALL: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-SMALL: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-SMALL: addf %{{.*}}, %{{.*}} : f32
// CHECK-SMALL: affine.store %{{.*}}, %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-SMALL: memref.dealloc %{{.*}} : memref<1x1xf32>
// CHECK-SMALL: dealloc %{{.*}} : memref<1x1xf32>
// CHECK-SMALL: }
// CHECK-SMALL: affine.load %{{.*}}[0, 0] : memref<1x1xf32>
// CHECK-SMALL: affine.store %{{.*}}, %arg{{.*}}[%{{.*}}, %{{.*}}] : memref<1024x1024xf32>
// CHECK-SMALL: memref.dealloc %{{.*}} : memref<1x1xf32>
// CHECK-SMALL: dealloc %{{.*}} : memref<1x1xf32>
// CHECK-SMALL: }
// CHECK-SMALL: }
// CHECK-SMALL: return

// Check that only one memref is copied when memref filter is used.

// FILTER: memref.alloc() : memref<1024x1024xf32>
// FILTER-NOT: memref.alloc()
// FILTER: alloc() : memref<1024x1024xf32>
// FILTER-NOT: alloc()
// FILTER: affine.for %{{.*}} = 0 to 1024 {
// FILTER: affine.for %{{.*}} = 0 to 1024 {
// FILTER: affine.for %{{.*}} = 0 to 1024 {
// FILTER-NEXT: affine.for %{{.*}} = 0 to 1024 {
// FILTER-NEXT: affine.for %{{.*}} = 0 to 1024 {
// FILTER: memref.dealloc %{{.*}} : memref<1024x1024xf32>
// FILTER-NOT: memref.dealloc
// FILTER: dealloc %{{.*}} : memref<1024x1024xf32>
// FILTER-NOT: dealloc
// FILTER: return

// CHeck that only one memref is copied, because for-memref-region is enabled
// (and the first ever encountered load is analyzed).
// MEMREF_REGION: memref.alloc() : memref<1024x1024xf32>
// MEMREF_REGION-NOT: memref.alloc()
// MEMREF_REGION: alloc() : memref<1024x1024xf32>
// MEMREF_REGION-NOT: alloc()
// MEMREF_REGION: affine.for %{{.*}} = 0 to 1024 {
// MEMREF_REGION: affine.for %{{.*}} = 0 to 1024 {
// MEMREF_REGION: }
// MEMREF_REGION: }
// MEMREF_REGION-NEXT: affine.for %{{.*}} = 0 to 1024 {
// MEMREF_REGION-NEXT: affine.for %{{.*}} = 0 to 1024 {
// MEMREF_REGION-NEXT: affine.for %{{.*}} = 0 to 1024 {
// MEMREF_REGION: memref.dealloc %{{.*}} : memref<1024x1024xf32>
// MEMREF_REGION-NOT: memref.dealloc
// MEMREF_REGION: dealloc %{{.*}} : memref<1024x1024xf32>
// MEMREF_REGION-NOT: dealloc
// MEMREF_REGION-NEXT: return

// -----
Expand All @@ -216,7 +216,7 @@ func @min_upper_bound(%A: memref<4096xf32>) -> memref<4096xf32> {
return %A : memref<4096xf32>
}
// CHECK: affine.for %[[IV1:.*]] = 0 to 4096 step 100
// CHECK: %[[BUF:.*]] = memref.alloc() : memref<100xf32>
// CHECK: %[[BUF:.*]] = alloc() : memref<100xf32>
// CHECK-NEXT: affine.for %[[IV2:.*]] = #[[$MAP_IDENTITY]](%[[IV1]]) to min #[[$MAP_MIN_UB1]](%[[IV1]]) {
// CHECK-NEXT: affine.load %{{.*}}[%[[IV2]]] : memref<4096xf32>
// CHECK-NEXT: affine.store %{{.*}}, %[[BUF]][%[[IV2]] - %[[IV1]]] : memref<100xf32>
Expand All @@ -230,7 +230,7 @@ func @min_upper_bound(%A: memref<4096xf32>) -> memref<4096xf32> {
// CHECK-NEXT: affine.load %[[BUF]][%[[IV2]] - %[[IV1]]] : memref<100xf32>
// CHECK-NEXT: affine.store %{{.*}}, %{{.*}}[%[[IV2]]] : memref<4096xf32>
// CHECK-NEXT: }
// CHECK-NEXT: memref.dealloc %[[BUF]] : memref<100xf32>
// CHECK-NEXT: dealloc %[[BUF]] : memref<100xf32>
// CHECK-NEXT: }

// -----
Expand All @@ -257,7 +257,7 @@ func @max_lower_bound(%M: memref<2048x516xf64>, %i : index, %j : index) {
return
}

// CHECK: %[[BUF:.*]] = memref.alloc() : memref<2048x6xf64>
// CHECK: %[[BUF:.*]] = alloc() : memref<2048x6xf64>
// CHECK-NEXT: affine.for %[[ii:.*]] = 0 to 2048 {
// CHECK-NEXT: affine.for %[[jj:.*]] = max #[[$LB]]()[%[[i]], %[[j]]] to min #[[$UB]]()[%[[i]], %[[j]]] {
// CHECK-NEXT: affine.load %{{.*}}[%[[ii]], %[[jj]]] : memref<2048x516xf64>
Expand All @@ -269,4 +269,4 @@ func @max_lower_bound(%M: memref<2048x516xf64>, %i : index, %j : index) {
// CHECK-NEXT: affine.load %[[BUF]][%[[ii_]], %[[jj_]] - symbol(%[[j]]) * 6] : memref<2048x6xf64>
// CHECK-NEXT: }
// CHECK-NEXT: }
// CHECK-NEXT: memref.dealloc %[[BUF]] : memref<2048x6xf64>
// CHECK-NEXT: dealloc %[[BUF]] : memref<2048x6xf64>
106 changes: 53 additions & 53 deletions mlir/test/Dialect/Affine/affine-loop-invariant-code-motion.mlir
View file
Original file line number Diff line number Diff line change
@@ -1,7 +1,7 @@
// RUN: mlir-opt %s -affine-loop-invariant-code-motion -split-input-file | FileCheck %s

func @nested_loops_both_having_invariant_code() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32

Expand All @@ -12,7 +12,7 @@ func @nested_loops_both_having_invariant_code() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// 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
Expand All @@ -29,14 +29,14 @@ func @nested_loops_both_having_invariant_code() {
// CHECK-LABEL: func @store_affine_apply
func @store_affine_apply() -> memref<10xf32> {
%cf7 = constant 7.0 : f32
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
affine.for %arg0 = 0 to 10 {
%t0 = affine.apply affine_map<(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 = memref.alloc() : memref<10xf32>
// CHECK-NEXT: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: %1 = affine.apply #map{{[0-9]*}}(%arg0)
// CHECK-NEXT: affine.store %cst, %0[%1] : memref<10xf32>
Expand All @@ -47,7 +47,7 @@ func @store_affine_apply() -> memref<10xf32> {
// -----

func @nested_loops_code_invariant_to_both() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32

Expand All @@ -57,7 +57,7 @@ func @nested_loops_code_invariant_to_both() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// 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
Expand All @@ -68,17 +68,17 @@ func @nested_loops_code_invariant_to_both() {
// -----

func @single_loop_nothing_invariant() {
%m1 = memref.alloc() : memref<10xf32>
%m2 = memref.alloc() : memref<10xf32>
%m1 = alloc() : memref<10xf32>
%m2 = alloc() : 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[%arg0] : memref<10xf32>
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK-NEXT: %1 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %1 = alloc() : 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>
Expand All @@ -91,7 +91,7 @@ func @single_loop_nothing_invariant() {
// -----

func @invariant_code_inside_affine_if() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32

affine.for %arg0 = 0 to 10 {
Expand All @@ -103,7 +103,7 @@ func @invariant_code_inside_affine_if() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: %1 = affine.apply #map{{[0-9]*}}(%arg0)
Expand All @@ -119,7 +119,7 @@ func @invariant_code_inside_affine_if() {
// -----

func @dependent_stores() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32

Expand All @@ -132,7 +132,7 @@ func @dependent_stores() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// 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
Expand All @@ -149,7 +149,7 @@ func @dependent_stores() {
// -----

func @independent_stores() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32

Expand All @@ -162,7 +162,7 @@ func @independent_stores() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// 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
Expand All @@ -179,7 +179,7 @@ func @independent_stores() {
// -----

func @load_dependent_store() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32

Expand All @@ -192,7 +192,7 @@ func @load_dependent_store() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// 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
Expand All @@ -208,7 +208,7 @@ func @load_dependent_store() {
// -----

func @load_after_load() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf7 = constant 7.0 : f32
%cf8 = constant 8.0 : f32

Expand All @@ -221,7 +221,7 @@ func @load_after_load() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// 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
Expand All @@ -237,7 +237,7 @@ func @load_after_load() {
// -----

func @invariant_affine_if() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
Expand All @@ -249,7 +249,7 @@ func @invariant_affine_if() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.if #set(%arg0, %arg0) {
Expand All @@ -264,7 +264,7 @@ func @invariant_affine_if() {
// -----

func @invariant_affine_if2() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
Expand All @@ -276,7 +276,7 @@ func @invariant_affine_if2() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
Expand All @@ -293,7 +293,7 @@ func @invariant_affine_if2() {
// -----

func @invariant_affine_nested_if() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
Expand All @@ -307,7 +307,7 @@ func @invariant_affine_nested_if() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
Expand All @@ -327,7 +327,7 @@ func @invariant_affine_nested_if() {
// -----

func @invariant_affine_nested_if_else() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
Expand All @@ -343,7 +343,7 @@ func @invariant_affine_nested_if_else() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
Expand All @@ -365,8 +365,8 @@ func @invariant_affine_nested_if_else() {
// -----

func @invariant_affine_nested_if_else2() {
%m = memref.alloc() : memref<10xf32>
%m2 = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%m2 = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
Expand All @@ -382,8 +382,8 @@ func @invariant_affine_nested_if_else2() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK-NEXT: %1 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %1 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.if #set(%arg0, %arg0) {
Expand All @@ -403,7 +403,7 @@ func @invariant_affine_nested_if_else2() {
// -----

func @invariant_affine_nested_if2() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
Expand All @@ -417,7 +417,7 @@ func @invariant_affine_nested_if2() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.if #set(%arg0, %arg0) {
Expand All @@ -435,7 +435,7 @@ func @invariant_affine_nested_if2() {
// -----

func @invariant_affine_for_inside_affine_if() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cf8 = constant 8.0 : f32
affine.for %arg0 = 0 to 10 {
affine.for %arg1 = 0 to 10 {
Expand All @@ -449,7 +449,7 @@ func @invariant_affine_for_inside_affine_if() {
}
}

// CHECK: %0 = memref.alloc() : memref<10xf32>
// CHECK: %0 = alloc() : memref<10xf32>
// CHECK-NEXT: %cst = constant 8.000000e+00 : f32
// CHECK-NEXT: affine.for %arg0 = 0 to 10 {
// CHECK-NEXT: affine.for %arg1 = 0 to 10 {
Expand All @@ -469,16 +469,16 @@ func @invariant_affine_for_inside_affine_if() {
// -----

func @invariant_constant_and_load() {
%m = memref.alloc() : memref<100xf32>
%m2 = memref.alloc() : memref<100xf32>
%m = alloc() : memref<100xf32>
%m2 = alloc() : memref<100xf32>
affine.for %arg0 = 0 to 5 {
%c0 = constant 0 : index
%v = affine.load %m2[%c0] : memref<100xf32>
affine.store %v, %m[%arg0] : memref<100xf32>
}

// CHECK: %0 = memref.alloc() : memref<100xf32>
// CHECK-NEXT: %1 = memref.alloc() : 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 %arg0 = 0 to 5 {
Expand All @@ -491,7 +491,7 @@ func @invariant_constant_and_load() {
// -----

func @nested_load_store_same_memref() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cst = constant 8.0 : f32
%c0 = constant 0 : index
affine.for %arg0 = 0 to 10 {
Expand All @@ -501,7 +501,7 @@ func @nested_load_store_same_memref() {
}
}

// CHECK: %0 = memref.alloc() : 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 %arg0 = 0 to 10 {
Expand All @@ -516,7 +516,7 @@ func @nested_load_store_same_memref() {
// -----

func @nested_load_store_same_memref2() {
%m = memref.alloc() : memref<10xf32>
%m = alloc() : memref<10xf32>
%cst = constant 8.0 : f32
%c0 = constant 0 : index
affine.for %arg0 = 0 to 10 {
Expand All @@ -526,7 +526,7 @@ func @nested_load_store_same_memref2() {
}
}

// CHECK: %0 = memref.alloc() : 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 %arg0 = 0 to 10 {
Expand All @@ -541,7 +541,7 @@ func @nested_load_store_same_memref2() {

// CHECK-LABEL: func @do_not_hoist_dependent_side_effect_free_op
func @do_not_hoist_dependent_side_effect_free_op(%arg0: memref<10x512xf32>) {
%0 = memref.alloca() : memref<1xf32>
%0 = alloca() : memref<1xf32>
%cst = constant 8.0 : f32
affine.for %i = 0 to 512 {
affine.for %j = 0 to 10 {
Expand Down Expand Up @@ -571,8 +571,8 @@ func @do_not_hoist_dependent_side_effect_free_op(%arg0: memref<10x512xf32>) {

// CHECK-LABEL: func @vector_loop_nothing_invariant
func @vector_loop_nothing_invariant() {
%m1 = memref.alloc() : memref<40xf32>
%m2 = memref.alloc() : memref<40xf32>
%m1 = alloc() : memref<40xf32>
%m2 = alloc() : memref<40xf32>
affine.for %arg0 = 0 to 10 {
%v0 = affine.vector_load %m1[%arg0*4] : memref<40xf32>, vector<4xf32>
%v1 = affine.vector_load %m2[%arg0*4] : memref<40xf32>, vector<4xf32>
Expand All @@ -593,9 +593,9 @@ func @vector_loop_nothing_invariant() {

// CHECK-LABEL: func @vector_loop_all_invariant
func @vector_loop_all_invariant() {
%m1 = memref.alloc() : memref<4xf32>
%m2 = memref.alloc() : memref<4xf32>
%m3 = memref.alloc() : memref<4xf32>
%m1 = alloc() : memref<4xf32>
%m2 = alloc() : memref<4xf32>
%m3 = alloc() : memref<4xf32>
affine.for %arg0 = 0 to 10 {
%v0 = affine.vector_load %m1[0] : memref<4xf32>, vector<4xf32>
%v1 = affine.vector_load %m2[0] : memref<4xf32>, vector<4xf32>
Expand All @@ -605,9 +605,9 @@ func @vector_loop_all_invariant() {
return
}

// CHECK: memref.alloc()
// CHECK-NEXT: memref.alloc()
// CHECK-NEXT: memref.alloc()
// CHECK: alloc()
// CHECK-NEXT: alloc()
// CHECK-NEXT: alloc()
// CHECK-NEXT: affine.vector_load
// CHECK-NEXT: affine.vector_load
// CHECK-NEXT: addf
Expand Down
2 changes: 1 addition & 1 deletion mlir/test/Dialect/Affine/affine-loop-normalize.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,7 @@
// CHECK-LABEL: func @normalize_parallel()
func @normalize_parallel() {
%cst = constant 1.0 : f32
%0 = memref.alloc() : memref<2x4xf32>
%0 = alloc() : memref<2x4xf32>
// CHECK: affine.parallel (%[[i0:.*]], %[[j0:.*]]) = (0, 0) to (4, 2)
affine.parallel (%i, %j) = (0, 1) to (10, 5) step (3, 2) {
// CHECK: %[[i1:.*]] = affine.apply [[$MAP0]](%[[i0]])
Expand Down
80 changes: 40 additions & 40 deletions mlir/test/Dialect/Affine/canonicalize.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@

// CHECK-LABEL: func @compose_affine_maps_1dto2d_no_symbols() {
func @compose_affine_maps_1dto2d_no_symbols() {
%0 = memref.alloc() : memref<4x4xf32>
%0 = alloc() : memref<4x4xf32>

affine.for %i0 = 0 to 15 {
// Test load[%x, %x]
Expand All @@ -26,21 +26,21 @@ func @compose_affine_maps_1dto2d_no_symbols() {
%y1_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%y0, %y0)

// CHECK-NEXT: %[[I1A:.*]] = affine.apply #[[$MAP1]](%{{.*}})
// CHECK-NEXT: memref.store %[[V0]], %0[%[[I1A]], %[[I1A]]]
memref.store %v0, %0[%y1_0, %y1_1] : memref<4x4xf32>
// CHECK-NEXT: store %[[V0]], %0[%[[I1A]], %[[I1A]]]
store %v0, %0[%y1_0, %y1_1] : memref<4x4xf32>

// Test store[%x, %y]
%xy_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%x0, %y0)
%xy_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%x0, %y0)

// CHECK-NEXT: memref.store %[[V0]], %0[%[[I0A]], %[[I1A]]]
memref.store %v0, %0[%xy_0, %xy_1] : memref<4x4xf32>
// CHECK-NEXT: store %[[V0]], %0[%[[I0A]], %[[I1A]]]
store %v0, %0[%xy_0, %xy_1] : memref<4x4xf32>

// Test store[%y, %x]
%yx_0 = affine.apply affine_map<(d0, d1) -> (d0)> (%y0, %x0)
%yx_1 = affine.apply affine_map<(d0, d1) -> (d1)> (%y0, %x0)
// CHECK-NEXT: memref.store %[[V0]], %0[%[[I1A]], %[[I0A]]]
memref.store %v0, %0[%yx_0, %yx_1] : memref<4x4xf32>
// CHECK-NEXT: store %[[V0]], %0[%[[I1A]], %[[I0A]]]
store %v0, %0[%yx_0, %yx_1] : memref<4x4xf32>
}
return
}
Expand All @@ -53,7 +53,7 @@ func @compose_affine_maps_1dto2d_no_symbols() {

// CHECK-LABEL: func @compose_affine_maps_1dto2d_with_symbols() {
func @compose_affine_maps_1dto2d_with_symbols() {
%0 = memref.alloc() : memref<4x4xf32>
%0 = alloc() : memref<4x4xf32>

affine.for %i0 = 0 to 15 {
// Test load[%x0, %x0] with symbol %c4
Expand All @@ -68,22 +68,22 @@ func @compose_affine_maps_1dto2d_with_symbols() {
%x1 = affine.apply affine_map<(d0) -> (d0 + 1)> (%i0)
%y1 = affine.apply affine_map<(d0, d1) -> (d0+d1)> (%x0, %x1)
// CHECK-NEXT: %[[I1:.*]] = affine.apply #[[$MAP7]](%{{.*}})
// CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I1]], %[[I1]]]
memref.store %v0, %0[%y1, %y1] : memref<4x4xf32>
// CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I1]], %[[I1]]]
store %v0, %0[%y1, %y1] : memref<4x4xf32>

// Test store[%x1, %x0] with symbol %c4 captured by '%x0' map.
%y2 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%x1, %x0)
// CHECK-NEXT: %[[I2:.*]] = affine.apply #[[$MAP7]](%{{.*}})
// CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I2]], %[[I2]]]
memref.store %v0, %0[%y2, %y2] : memref<4x4xf32>
// CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I2]], %[[I2]]]
store %v0, %0[%y2, %y2] : memref<4x4xf32>

// Test store[%x2, %x0] with symbol %c4 from '%x0' and %c5 from '%x2'
%c5 = constant 5 : index
%x2 = affine.apply affine_map<(d0)[s0] -> (d0 + s0)> (%i0)[%c5]
%y3 = affine.apply affine_map<(d0, d1) -> (d0 + d1)> (%x2, %x0)
// CHECK: %[[I3:.*]] = affine.apply #[[$MAP7a]](%{{.*}})
// CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I3]], %[[I3]]]
memref.store %v0, %0[%y3, %y3] : memref<4x4xf32>
// CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I3]], %[[I3]]]
store %v0, %0[%y3, %y3] : memref<4x4xf32>
}
return
}
Expand All @@ -95,8 +95,8 @@ func @compose_affine_maps_1dto2d_with_symbols() {

// CHECK-LABEL: func @compose_affine_maps_2d_tile() {
func @compose_affine_maps_2d_tile() {
%0 = memref.alloc() : memref<16x32xf32>
%1 = memref.alloc() : memref<16x32xf32>
%0 = alloc() : memref<16x32xf32>
%1 = alloc() : memref<16x32xf32>

%c4 = constant 4 : index
%c8 = constant 8 : index
Expand All @@ -119,8 +119,8 @@ func @compose_affine_maps_2d_tile() {
// CHECK-NEXT: %[[L0:.*]] = load %{{.*}}[%[[I0]], %[[I1]]]
%v0 = load %0[%x40, %x41] : memref<16x32xf32>

// CHECK-NEXT: memref.store %[[L0]], %{{.*}}[%[[I0]], %[[I1]]]
memref.store %v0, %1[%x40, %x41] : memref<16x32xf32>
// CHECK-NEXT: store %[[L0]], %{{.*}}[%[[I0]], %[[I1]]]
store %v0, %1[%x40, %x41] : memref<16x32xf32>
}
}
}
Expand All @@ -138,8 +138,8 @@ func @compose_affine_maps_2d_tile() {

// CHECK-LABEL: func @compose_affine_maps_dependent_loads() {
func @compose_affine_maps_dependent_loads() {
%0 = memref.alloc() : memref<16x32xf32>
%1 = memref.alloc() : memref<16x32xf32>
%0 = alloc() : memref<16x32xf32>
%1 = alloc() : memref<16x32xf32>

affine.for %i0 = 0 to 3 {
affine.for %i1 = 0 to 3 {
Expand All @@ -160,12 +160,12 @@ func @compose_affine_maps_dependent_loads() {
// CHECK-NEXT: %[[V0:.*]] = load %{{.*}}[%[[I0]], %[[I1]]]
%v0 = load %0[%x00, %x01] : memref<16x32xf32>

// CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I0]], %[[I2]]]
memref.store %v0, %0[%x00, %x02] : memref<16x32xf32>
// CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I0]], %[[I2]]]
store %v0, %0[%x00, %x02] : memref<16x32xf32>

// Swizzle %i0, %i1
// CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I1]], %[[I0]]]
memref.store %v0, %0[%x01, %x00] : memref<16x32xf32>
// CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I1]], %[[I0]]]
store %v0, %0[%x01, %x00] : memref<16x32xf32>

// Swizzle %x00, %x01 and %c3, %c7
%x10 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d0 * s1)>
Expand All @@ -175,8 +175,8 @@ func @compose_affine_maps_dependent_loads() {

// CHECK-NEXT: %[[I2A:.*]] = affine.apply #[[$MAP12]](%{{.*}})
// CHECK-NEXT: %[[I2B:.*]] = affine.apply #[[$MAP11]](%{{.*}})
// CHECK-NEXT: memref.store %[[V0]], %{{.*}}[%[[I2A]], %[[I2B]]]
memref.store %v0, %0[%x10, %x11] : memref<16x32xf32>
// CHECK-NEXT: store %[[V0]], %{{.*}}[%[[I2A]], %[[I2B]]]
store %v0, %0[%x10, %x11] : memref<16x32xf32>
}
}
}
Expand All @@ -198,8 +198,8 @@ func @compose_affine_maps_diamond_dependency(%arg0: f32, %arg1: memref<4x4xf32>)
%d1 = affine.apply affine_map<(d0, d1) -> (d1 floordiv 3)> (%b, %c)
// CHECK: %[[I0:.*]] = affine.apply #[[$MAP13A]](%{{.*}})
// CHECK: %[[I1:.*]] = affine.apply #[[$MAP13B]](%{{.*}})
// CHECK-NEXT: memref.store %arg0, %arg1[%[[I0]], %[[I1]]]
memref.store %arg0, %arg1[%d0, %d1] : memref<4x4xf32>
// CHECK-NEXT: store %arg0, %arg1[%[[I0]], %[[I1]]]
store %arg0, %arg1[%d0, %d1] : memref<4x4xf32>
}

return
Expand All @@ -223,16 +223,16 @@ func @compose_affine_maps_multiple_symbols(%arg0: index, %arg1: index) -> index
// CHECK-LABEL: func @arg_used_as_dim_and_symbol
func @arg_used_as_dim_and_symbol(%arg0: memref<100x100xf32>, %arg1: index, %arg2: f32) {
%c9 = constant 9 : index
%1 = memref.alloc() : memref<100x100xf32, 1>
%2 = memref.alloc() : memref<1xi32>
%1 = alloc() : memref<100x100xf32, 1>
%2 = alloc() : memref<1xi32>
affine.for %i0 = 0 to 100 {
affine.for %i1 = 0 to 100 {
%3 = affine.apply affine_map<(d0, d1)[s0, s1] -> (d1 + s0 + s1)>
(%i0, %i1)[%arg1, %c9]
%4 = affine.apply affine_map<(d0, d1, d3) -> (d3 - (d0 + d1))>
(%arg1, %c9, %3)
// CHECK: memref.store %arg2, %{{.*}}[%{{.*}}, %{{.*}}]
memref.store %arg2, %1[%4, %arg1] : memref<100x100xf32, 1>
// CHECK: store %arg2, %{{.*}}[%{{.*}}, %{{.*}}]
store %arg2, %1[%4, %arg1] : memref<100x100xf32, 1>
}
}
return
Expand All @@ -244,17 +244,17 @@ func @arg_used_as_dim_and_symbol(%arg0: memref<100x100xf32>, %arg1: index, %arg2
func @trivial_maps() {
// CHECK-NOT: affine.apply

%0 = memref.alloc() : memref<10xf32>
%0 = alloc() : memref<10xf32>
%c0 = constant 0 : index
%cst = constant 0.000000e+00 : f32
affine.for %i1 = 0 to 10 {
%1 = affine.apply affine_map<()[s0] -> (s0)>()[%c0]
memref.store %cst, %0[%1] : memref<10xf32>
store %cst, %0[%1] : memref<10xf32>
%2 = load %0[%c0] : memref<10xf32>

%3 = affine.apply affine_map<()[] -> (0)>()[]
memref.store %cst, %0[%3] : memref<10xf32>
memref.store %2, %0[%c0] : memref<10xf32>
store %cst, %0[%3] : memref<10xf32>
store %2, %0[%c0] : memref<10xf32>
}
return
}
Expand Down Expand Up @@ -422,7 +422,7 @@ func @symbolic_semi_affine(%M: index, %N: index, %A: memref<?xf32>) {
%1 = affine.apply affine_map<()[s0] -> (s0 + 1)> ()[%M]
%2 = affine.apply affine_map<(d0)[s0] -> (d0 floordiv s0)> (%i0)[%1]
// CHECK-DAG: {{.*}} = affine.apply #[[$symbolic_semi_affine]](%{{.*}})[%{{.*}}]
memref.store %f1, %A[%2] : memref<?xf32>
store %f1, %A[%2] : memref<?xf32>
}
return
}
Expand Down Expand Up @@ -667,7 +667,7 @@ func @affine_parallel_const_bounds() {
%cst = constant 1.0 : f32
%c0 = constant 0 : index
%c4 = constant 4 : index
%0 = memref.alloc() : memref<4xf32>
%0 = alloc() : memref<4xf32>
// CHECK: affine.parallel (%{{.*}}) = (0) to (4)
affine.parallel (%i) = (%c0) to (%c0 + %c4) {
%1 = affine.apply #map3(%i)
Expand All @@ -686,11 +686,11 @@ func @compose_affine_maps_div_symbol(%A : memref<i64>, %i0 : index, %i1 : index)
%1 = affine.apply affine_map<()[s0] -> (3 * s0)> ()[%i0]
%2 = affine.apply affine_map<(d0)[s0, s1] -> (d0 mod s1 + s0 * s1 + s0 * 4)> (%i1)[%0, %1]
%3 = index_cast %2: index to i64
memref.store %3, %A[]: memref<i64>
store %3, %A[]: memref<i64>
affine.for %i2 = 0 to 3 {
%4 = affine.apply affine_map<(d0)[s0, s1] -> (d0 ceildiv s1 + s0 + s0 * 3)> (%i2)[%0, %1]
%5 = index_cast %4: index to i64
memref.store %5, %A[]: memref<i64>
store %5, %A[]: memref<i64>
}
return
}
118 changes: 59 additions & 59 deletions mlir/test/Dialect/Affine/dma-generate.mlir
View file

Large diffs are not rendered by default.

30 changes: 15 additions & 15 deletions mlir/test/Dialect/Affine/dma.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,9 +4,9 @@

// Test with loop IVs.
func @test0(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%1 = memref.alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
%2 = memref.alloc() : memref<1xi32>
%0 = alloc() : memref<100x100xf32>
%1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
%2 = alloc() : memref<1xi32>
%c0 = constant 0 : index
%c64 = constant 64 : index
affine.for %i0 = 0 to 10 {
Expand All @@ -25,9 +25,9 @@ func @test0(%arg0 : index, %arg1 : index) {

// Test with loop IVs and optional stride arguments.
func @test1(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%1 = memref.alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
%2 = memref.alloc() : memref<1xi32>
%0 = alloc() : memref<100x100xf32>
%1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
%2 = alloc() : memref<1xi32>
%c0 = constant 0 : index
%c64 = constant 64 : index
%c128 = constant 128 : index
Expand All @@ -48,9 +48,9 @@ func @test1(%arg0 : index, %arg1 : index) {

// Test with loop IVs and symbols (without symbol keyword).
func @test2(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%1 = memref.alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
%2 = memref.alloc() : memref<1xi32>
%0 = alloc() : memref<100x100xf32>
%1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
%2 = alloc() : memref<1xi32>
%c0 = constant 0 : index
%c64 = constant 64 : index
affine.for %i0 = 0 to 10 {
Expand All @@ -70,9 +70,9 @@ func @test2(%arg0 : index, %arg1 : index) {

// Test with loop IVs and symbols (with symbol keyword).
func @test3(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%1 = memref.alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
%2 = memref.alloc() : memref<1xi32>
%0 = alloc() : memref<100x100xf32>
%1 = alloc() : memref<100x100xf32, affine_map<(d0, d1) -> (d0, d1)>, 2>
%2 = alloc() : memref<1xi32>
%c0 = constant 0 : index
%c64 = constant 64 : index
affine.for %i0 = 0 to 10 {
Expand All @@ -93,9 +93,9 @@ func @test3(%arg0 : index, %arg1 : index) {

// Test with loop IVs, symbols and constants in nested affine expressions.
func @test4(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%1 = memref.alloc() : memref<100x100xf32, 2>
%2 = memref.alloc() : memref<1xi32>
%0 = alloc() : memref<100x100xf32>
%1 = alloc() : memref<100x100xf32, 2>
%2 = alloc() : memref<1xi32>
%c64 = constant 64 : index
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
Expand Down
16 changes: 8 additions & 8 deletions mlir/test/Dialect/Affine/invalid.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -121,7 +121,7 @@ func @affine_if_invalid_sym() {

func @affine_if_invalid_dimop_dim(%arg0: index, %arg1: index, %arg2: index, %arg3: index) {
affine.for %n0 = 0 to 7 {
%0 = memref.alloc(%arg0, %arg1, %arg2, %arg3) : memref<?x?x?x?xf32>
%0 = alloc(%arg0, %arg1, %arg2, %arg3) : memref<?x?x?x?xf32>
%c0 = constant 0 : index
%dim = dim %0, %c0 : memref<?x?x?x?xf32>

Expand Down Expand Up @@ -253,7 +253,7 @@ func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
// -----

func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
// expected-error@+1 {{reduction must be specified for each output}}
%1 = affine.parallel (%i, %j) = (0, 0) to (100, 100) step (10, 10) -> (f32) {
%2 = affine.load %0[%i, %j] : memref<100x100xf32>
Expand All @@ -265,7 +265,7 @@ func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
// -----

func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
// expected-error@+1 {{invalid reduction value: "bad"}}
%1 = affine.parallel (%i, %j) = (0, 0) to (100, 100) step (10, 10) reduce ("bad") -> (f32) {
%2 = affine.load %0[%i, %j] : memref<100x100xf32>
Expand All @@ -277,7 +277,7 @@ func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
// -----

func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
%0 = memref.alloc() : memref<100x100xi32>
%0 = alloc() : memref<100x100xi32>
%1 = affine.parallel (%i, %j) = (0, 0) to (100, 100) step (10, 10) reduce ("minf") -> (f32) {
%2 = affine.load %0[%i, %j] : memref<100x100xi32>
// expected-error@+1 {{types mismatch between yield op and its parent}}
Expand All @@ -289,7 +289,7 @@ func @affine_parallel(%arg0 : index, %arg1 : index, %arg2 : index) {
// -----

func @vector_load_invalid_vector_type() {
%0 = memref.alloc() : memref<100xf32>
%0 = alloc() : memref<100xf32>
affine.for %i0 = 0 to 16 step 8 {
// expected-error@+1 {{requires memref and vector types of the same elemental type}}
%1 = affine.vector_load %0[%i0] : memref<100xf32>, vector<8xf64>
Expand All @@ -300,7 +300,7 @@ func @vector_load_invalid_vector_type() {
// -----

func @vector_store_invalid_vector_type() {
%0 = memref.alloc() : memref<100xf32>
%0 = alloc() : memref<100xf32>
%1 = constant dense<7.0> : vector<8xf64>
affine.for %i0 = 0 to 16 step 8 {
// expected-error@+1 {{requires memref and vector types of the same elemental type}}
Expand All @@ -312,7 +312,7 @@ func @vector_store_invalid_vector_type() {
// -----

func @vector_load_vector_memref() {
%0 = memref.alloc() : memref<100xvector<8xf32>>
%0 = alloc() : memref<100xvector<8xf32>>
affine.for %i0 = 0 to 4 {
// expected-error@+1 {{requires memref and vector types of the same elemental type}}
%1 = affine.vector_load %0[%i0] : memref<100xvector<8xf32>>, vector<8xf32>
Expand All @@ -323,7 +323,7 @@ func @vector_load_vector_memref() {
// -----

func @vector_store_vector_memref() {
%0 = memref.alloc() : memref<100xvector<8xf32>>
%0 = alloc() : memref<100xvector<8xf32>>
%1 = constant dense<7.0> : vector<8xf32>
affine.for %i0 = 0 to 4 {
// expected-error@+1 {{requires memref and vector types of the same elemental type}}
Expand Down
32 changes: 16 additions & 16 deletions mlir/test/Dialect/Affine/load-store-invalid.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -63,7 +63,7 @@ func @store_too_few_subscripts_map(%arg0: memref<?x?xf32>, %arg1: index, %val: f
// -----

func @load_non_affine_index(%arg0 : index) {
%0 = memref.alloc() : memref<10xf32>
%0 = alloc() : memref<10xf32>
affine.for %i0 = 0 to 10 {
%1 = muli %i0, %arg0 : index
// expected-error@+1 {{op index must be a dimension or symbol identifier}}
Expand All @@ -75,7 +75,7 @@ func @load_non_affine_index(%arg0 : index) {
// -----

func @store_non_affine_index(%arg0 : index) {
%0 = memref.alloc() : memref<10xf32>
%0 = alloc() : memref<10xf32>
%1 = constant 11.0 : f32
affine.for %i0 = 0 to 10 {
%2 = muli %i0, %arg0 : index
Expand All @@ -88,7 +88,7 @@ func @store_non_affine_index(%arg0 : index) {
// -----

func @invalid_prefetch_rw(%i : index) {
%0 = memref.alloc() : memref<10xf32>
%0 = alloc() : memref<10xf32>
// expected-error@+1 {{rw specifier has to be 'read' or 'write'}}
affine.prefetch %0[%i], rw, locality<0>, data : memref<10xf32>
return
Expand All @@ -97,7 +97,7 @@ func @invalid_prefetch_rw(%i : index) {
// -----

func @invalid_prefetch_cache_type(%i : index) {
%0 = memref.alloc() : memref<10xf32>
%0 = alloc() : memref<10xf32>
// expected-error@+1 {{cache type has to be 'data' or 'instr'}}
affine.prefetch %0[%i], read, locality<0>, false : memref<10xf32>
return
Expand All @@ -106,9 +106,9 @@ func @invalid_prefetch_cache_type(%i : index) {
// -----

func @dma_start_non_affine_src_index(%arg0 : index) {
%0 = memref.alloc() : memref<100xf32>
%1 = memref.alloc() : memref<100xf32, 2>
%2 = memref.alloc() : memref<1xi32, 4>
%0 = alloc() : memref<100xf32>
%1 = alloc() : memref<100xf32, 2>
%2 = alloc() : memref<1xi32, 4>
%c0 = constant 0 : index
%c64 = constant 64 : index
affine.for %i0 = 0 to 10 {
Expand All @@ -123,9 +123,9 @@ func @dma_start_non_affine_src_index(%arg0 : index) {
// -----

func @dma_start_non_affine_dst_index(%arg0 : index) {
%0 = memref.alloc() : memref<100xf32>
%1 = memref.alloc() : memref<100xf32, 2>
%2 = memref.alloc() : memref<1xi32, 4>
%0 = alloc() : memref<100xf32>
%1 = alloc() : memref<100xf32, 2>
%2 = alloc() : memref<1xi32, 4>
%c0 = constant 0 : index
%c64 = constant 64 : index
affine.for %i0 = 0 to 10 {
Expand All @@ -140,9 +140,9 @@ func @dma_start_non_affine_dst_index(%arg0 : index) {
// -----

func @dma_start_non_affine_tag_index(%arg0 : index) {
%0 = memref.alloc() : memref<100xf32>
%1 = memref.alloc() : memref<100xf32, 2>
%2 = memref.alloc() : memref<1xi32, 4>
%0 = alloc() : memref<100xf32>
%1 = alloc() : memref<100xf32, 2>
%2 = alloc() : memref<1xi32, 4>
%c0 = constant 0 : index
%c64 = constant 64 : index
affine.for %i0 = 0 to 10 {
Expand All @@ -157,9 +157,9 @@ func @dma_start_non_affine_tag_index(%arg0 : index) {
// -----

func @dma_wait_non_affine_tag_index(%arg0 : index) {
%0 = memref.alloc() : memref<100xf32>
%1 = memref.alloc() : memref<100xf32, 2>
%2 = memref.alloc() : memref<1xi32, 4>
%0 = alloc() : memref<100xf32>
%1 = alloc() : memref<100xf32, 2>
%2 = alloc() : memref<1xi32, 4>
%c0 = constant 0 : index
%c64 = constant 64 : index
affine.for %i0 = 0 to 10 {
Expand Down
32 changes: 16 additions & 16 deletions mlir/test/Dialect/Affine/load-store.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,7 @@

// Test with just loop IVs.
func @test0(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%i0, %i1] : memref<100x100xf32>
Expand All @@ -18,7 +18,7 @@ func @test0(%arg0 : index, %arg1 : index) {

// Test with loop IVs and constants.
func @test1(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
Expand All @@ -35,7 +35,7 @@ func @test1(%arg0 : index, %arg1 : index) {
// Test with loop IVs and function args without 'symbol' keyword (should
// be parsed as dim identifiers).
func @test2(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%i0 + %arg0, %i1 + %arg1] : memref<100x100xf32>
Expand All @@ -52,7 +52,7 @@ func @test2(%arg0 : index, %arg1 : index) {
// Test with loop IVs and function args with 'symbol' keyword (should
// be parsed as symbol identifiers).
func @test3(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%i0 + symbol(%arg0), %i1 + symbol(%arg1)]
Expand All @@ -70,7 +70,7 @@ func @test3(%arg0 : index, %arg1 : index) {

// Test with loop IVs, symbols and constants in nested affine expressions.
func @test4(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[(%i0 + symbol(%arg0)) floordiv 3 + 11,
Expand All @@ -88,7 +88,7 @@ func @test4(%arg0 : index, %arg1 : index) {

// Test with swizzled loop IVs.
func @test5(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<10x10x10xf32>
%0 = alloc() : memref<10x10x10xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.for %i2 = 0 to 10 {
Expand All @@ -108,7 +108,7 @@ func @test5(%arg0 : index, %arg1 : index) {
// Dim identifiers are assigned in parse order:
// d0 = %i2, d1 = %arg0, d2 = %i0, d3 = %i1, d4 = %arg1
func @test6(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<10x10x10xf32>
%0 = alloc() : memref<10x10x10xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.for %i2 = 0 to 10 {
Expand All @@ -131,7 +131,7 @@ func @test6(%arg0 : index, %arg1 : index) {
// d0 = %i2, d1 = %i0, d2 = %i1
// s0 = %arg0, s1 = %arg1
func @test6(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<10x10x10xf32>
%0 = alloc() : memref<10x10x10xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
affine.for %i2 = 0 to 10 {
Expand All @@ -157,7 +157,7 @@ func @test6(%arg0 : index, %arg1 : index) {

// Test with operands without special SSA name.
func @test7() {
%0 = memref.alloc() : memref<10xf32>
%0 = alloc() : memref<10xf32>
affine.for %i0 = 0 to 10 {
%1 = affine.apply affine_map<(d1) -> (d1 + 1)>(%i0)
%2 = affine.load %0[%1] : memref<10xf32>
Expand All @@ -183,7 +183,7 @@ func @zero_dim(%arg0 : memref<i32>, %arg1 : memref<i32>) {

// Test with loop IVs and constants.
func @test_prefetch(%arg0 : index, %arg1 : index) {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 10 {
%1 = affine.load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>
Expand All @@ -200,12 +200,12 @@ func @test_prefetch(%arg0 : index, %arg1 : index) {

// Test with just loop IVs.
func @vector_load_vector_store_iv() {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 16 {
affine.for %i1 = 0 to 16 step 8 {
%1 = affine.vector_load %0[%i0, %i1] : memref<100x100xf32>, vector<8xf32>
affine.vector_store %1, %0[%i0, %i1] : memref<100x100xf32>, vector<8xf32>
// CHECK: %[[buf:.*]] = memref.alloc
// CHECK: %[[buf:.*]] = alloc
// CHECK-NEXT: affine.for %[[i0:.*]] = 0
// CHECK-NEXT: affine.for %[[i1:.*]] = 0
// CHECK-NEXT: %[[val:.*]] = affine.vector_load %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<8xf32>
Expand All @@ -219,12 +219,12 @@ func @vector_load_vector_store_iv() {

// Test with loop IVs and constants.
func @vector_load_vector_store_iv_constant() {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 10 {
affine.for %i1 = 0 to 16 step 4 {
%1 = affine.vector_load %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>, vector<4xf32>
affine.vector_store %1, %0[%i0 + 3, %i1 + 7] : memref<100x100xf32>, vector<4xf32>
// CHECK: %[[buf:.*]] = memref.alloc
// CHECK: %[[buf:.*]] = alloc
// CHECK-NEXT: affine.for %[[i0:.*]] = 0
// CHECK-NEXT: affine.for %[[i1:.*]] = 0
// CHECK-NEXT: %[[val:.*]] = affine.vector_load %{{.*}}[%{{.*}} + 3, %{{.*}} + 7] : memref<100x100xf32>, vector<4xf32>
Expand All @@ -237,12 +237,12 @@ func @vector_load_vector_store_iv_constant() {
// -----

func @vector_load_vector_store_2d() {
%0 = memref.alloc() : memref<100x100xf32>
%0 = alloc() : memref<100x100xf32>
affine.for %i0 = 0 to 16 step 2{
affine.for %i1 = 0 to 16 step 8 {
%1 = affine.vector_load %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
affine.vector_store %1, %0[%i0, %i1] : memref<100x100xf32>, vector<2x8xf32>
// CHECK: %[[buf:.*]] = memref.alloc
// CHECK: %[[buf:.*]] = alloc
// CHECK-NEXT: affine.for %[[i0:.*]] = 0
// CHECK-NEXT: affine.for %[[i1:.*]] = 0
// CHECK-NEXT: %[[val:.*]] = affine.vector_load %[[buf]][%[[i0]], %[[i1]]] : memref<100x100xf32>, vector<2x8xf32>
Expand Down
4 changes: 2 additions & 2 deletions mlir/test/Dialect/Affine/loop-tiling-validity.mlir
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,7 @@

// CHECK-LABEL: func @legal_loop()
func @legal_loop() {
%0 = memref.alloc() : memref<64xf32>
%0 = alloc() : memref<64xf32>

affine.for %i = 0 to 64 {
%1 = affine.load %0[%i] : memref<64xf32>
Expand All @@ -32,7 +32,7 @@ func @legal_loop() {

// CHECK-LABEL: func @illegal_loop_with_diag_dependence
func @illegal_loop_with_diag_dependence() {
%A = memref.alloc() : memref<64x64xf32>
%A = alloc() : memref<64x64xf32>

affine.for %i = 0 to 64 {
// expected-remark@above {{tiled code is illegal due to dependences}}
Expand Down
Loading