1// RUN: mlir-opt -convert-std-to-llvm -split-input-file %s | FileCheck %s 2// RUN: mlir-opt -convert-std-to-llvm='use-bare-ptr-memref-call-conv=1' -split-input-file %s | FileCheck %s --check-prefix=BAREPTR 3 4// BAREPTR-LABEL: func @check_noalias 5// BAREPTR-SAME: %{{.*}}: !llvm.ptr<f32> {llvm.noalias}, %{{.*}}: !llvm.ptr<f32> {llvm.noalias} 6func @check_noalias(%static : memref<2xf32> {llvm.noalias}, %other : memref<2xf32> {llvm.noalias}) { 7 return 8} 9 10// ----- 11 12// CHECK-LABEL: func @check_strided_memref_arguments( 13// CHECK-COUNT-2: !llvm.ptr<f32> 14// CHECK-COUNT-5: i64 15// CHECK-COUNT-2: !llvm.ptr<f32> 16// CHECK-COUNT-5: i64 17// CHECK-COUNT-2: !llvm.ptr<f32> 18// CHECK-COUNT-5: i64 19func @check_strided_memref_arguments(%static: memref<10x20xf32, affine_map<(i,j)->(20 * i + j + 1)>>, 20 %dynamic : memref<?x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>, 21 %mixed : memref<10x?xf32, affine_map<(i,j)[M]->(M * i + j + 1)>>) { 22 return 23} 24 25// ----- 26 27// CHECK-LABEL: func @memref_index 28// CHECK-SAME: %arg0: !llvm.ptr<i64>, %arg1: !llvm.ptr<i64>, 29// CHECK-SAME: %arg2: i64, %arg3: i64, %arg4: i64) 30// CHECK-SAME: -> !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<1 x i64>, array<1 x i64>)> 31// CHECK32-LABEL: func @memref_index 32// CHECK32-SAME: %arg0: !llvm.ptr<i32>, %arg1: !llvm.ptr<i32>, 33// CHECK32-SAME: %arg2: i32, %arg3: i32, %arg4: i32) 34// CHECK32-SAME: -> !llvm.struct<(ptr<i32>, ptr<i32>, i32, array<1 x i32>, array<1 x i32>)> 35func @memref_index(%arg0: memref<32xindex>) -> memref<32xindex> { 36 return %arg0 : memref<32xindex> 37} 38 39// ----- 40 41// CHECK-LABEL: func @check_arguments 42// CHECK-COUNT-2: !llvm.ptr<f32> 43// CHECK-COUNT-5: i64 44// CHECK-COUNT-2: !llvm.ptr<f32> 45// CHECK-COUNT-5: i64 46// CHECK-COUNT-2: !llvm.ptr<f32> 47// CHECK-COUNT-5: i64 48func @check_arguments(%static: memref<10x20xf32>, %dynamic : memref<?x?xf32>, %mixed : memref<10x?xf32>) { 49 return 50} 51 52// ----- 53 54// CHECK-LABEL: func @check_static_return 55// CHECK-COUNT-2: !llvm.ptr<f32> 56// CHECK-COUNT-5: i64 57// CHECK-SAME: -> !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 58// BAREPTR-LABEL: func @check_static_return 59// BAREPTR-SAME: (%[[arg:.*]]: !llvm.ptr<f32>) -> !llvm.ptr<f32> { 60func @check_static_return(%static : memref<32x18xf32>) -> memref<32x18xf32> { 61// CHECK: llvm.return %{{.*}} : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 62 63// BAREPTR: %[[udf:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 64// BAREPTR-NEXT: %[[base0:.*]] = llvm.insertvalue %[[arg]], %[[udf]][0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 65// BAREPTR-NEXT: %[[aligned:.*]] = llvm.insertvalue %[[arg]], %[[base0]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 66// BAREPTR-NEXT: %[[val0:.*]] = llvm.mlir.constant(0 : index) : i64 67// BAREPTR-NEXT: %[[ins0:.*]] = llvm.insertvalue %[[val0]], %[[aligned]][2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 68// BAREPTR-NEXT: %[[val1:.*]] = llvm.mlir.constant(32 : index) : i64 69// BAREPTR-NEXT: %[[ins1:.*]] = llvm.insertvalue %[[val1]], %[[ins0]][3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 70// BAREPTR-NEXT: %[[val2:.*]] = llvm.mlir.constant(18 : index) : i64 71// BAREPTR-NEXT: %[[ins2:.*]] = llvm.insertvalue %[[val2]], %[[ins1]][4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 72// BAREPTR-NEXT: %[[val3:.*]] = llvm.mlir.constant(18 : index) : i64 73// BAREPTR-NEXT: %[[ins3:.*]] = llvm.insertvalue %[[val3]], %[[ins2]][3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 74// BAREPTR-NEXT: %[[val4:.*]] = llvm.mlir.constant(1 : index) : i64 75// BAREPTR-NEXT: %[[ins4:.*]] = llvm.insertvalue %[[val4]], %[[ins3]][4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 76// BAREPTR-NEXT: %[[base1:.*]] = llvm.extractvalue %[[ins4]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 77// BAREPTR-NEXT: llvm.return %[[base1]] : !llvm.ptr<f32> 78 return %static : memref<32x18xf32> 79} 80 81// ----- 82 83// CHECK-LABEL: func @check_static_return_with_offset 84// CHECK-COUNT-2: !llvm.ptr<f32> 85// CHECK-COUNT-5: i64 86// CHECK-SAME: -> !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 87// BAREPTR-LABEL: func @check_static_return_with_offset 88// BAREPTR-SAME: (%[[arg:.*]]: !llvm.ptr<f32>) -> !llvm.ptr<f32> { 89func @check_static_return_with_offset(%static : memref<32x18xf32, offset:7, strides:[22,1]>) -> memref<32x18xf32, offset:7, strides:[22,1]> { 90// CHECK: llvm.return %{{.*}} : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 91 92// BAREPTR: %[[udf:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 93// BAREPTR-NEXT: %[[base0:.*]] = llvm.insertvalue %[[arg]], %[[udf]][0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 94// BAREPTR-NEXT: %[[aligned:.*]] = llvm.insertvalue %[[arg]], %[[base0]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 95// BAREPTR-NEXT: %[[val0:.*]] = llvm.mlir.constant(7 : index) : i64 96// BAREPTR-NEXT: %[[ins0:.*]] = llvm.insertvalue %[[val0]], %[[aligned]][2] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 97// BAREPTR-NEXT: %[[val1:.*]] = llvm.mlir.constant(32 : index) : i64 98// BAREPTR-NEXT: %[[ins1:.*]] = llvm.insertvalue %[[val1]], %[[ins0]][3, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 99// BAREPTR-NEXT: %[[val2:.*]] = llvm.mlir.constant(22 : index) : i64 100// BAREPTR-NEXT: %[[ins2:.*]] = llvm.insertvalue %[[val2]], %[[ins1]][4, 0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 101// BAREPTR-NEXT: %[[val3:.*]] = llvm.mlir.constant(18 : index) : i64 102// BAREPTR-NEXT: %[[ins3:.*]] = llvm.insertvalue %[[val3]], %[[ins2]][3, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 103// BAREPTR-NEXT: %[[val4:.*]] = llvm.mlir.constant(1 : index) : i64 104// BAREPTR-NEXT: %[[ins4:.*]] = llvm.insertvalue %[[val4]], %[[ins3]][4, 1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 105// BAREPTR-NEXT: %[[base1:.*]] = llvm.extractvalue %[[ins4]][1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<2 x i64>, array<2 x i64>)> 106// BAREPTR-NEXT: llvm.return %[[base1]] : !llvm.ptr<f32> 107 return %static : memref<32x18xf32, offset:7, strides:[22,1]> 108} 109 110// ----- 111 112// BAREPTR: llvm.func @foo(!llvm.ptr<i8>) -> !llvm.ptr<i8> 113func private @foo(memref<10xi8>) -> memref<20xi8> 114 115// BAREPTR-LABEL: func @check_memref_func_call 116// BAREPTR-SAME: %[[in:.*]]: !llvm.ptr<i8>) -> !llvm.ptr<i8> 117func @check_memref_func_call(%in : memref<10xi8>) -> memref<20xi8> { 118 // BAREPTR: %[[inDesc:.*]] = llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] 119 // BAREPTR-NEXT: %[[barePtr:.*]] = llvm.extractvalue %[[inDesc]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> 120 // BAREPTR-NEXT: %[[call:.*]] = llvm.call @foo(%[[barePtr]]) : (!llvm.ptr<i8>) -> !llvm.ptr<i8> 121 // BAREPTR-NEXT: %[[desc0:.*]] = llvm.mlir.undef : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> 122 // BAREPTR-NEXT: %[[desc1:.*]] = llvm.insertvalue %[[call]], %[[desc0]][0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> 123 // BAREPTR-NEXT: %[[desc2:.*]] = llvm.insertvalue %[[call]], %[[desc1]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> 124 // BAREPTR-NEXT: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64 125 // BAREPTR-NEXT: %[[desc4:.*]] = llvm.insertvalue %[[c0]], %[[desc2]][2] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> 126 // BAREPTR-NEXT: %[[c20:.*]] = llvm.mlir.constant(20 : index) : i64 127 // BAREPTR-NEXT: %[[desc6:.*]] = llvm.insertvalue %[[c20]], %[[desc4]][3, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> 128 // BAREPTR-NEXT: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64 129 // BAREPTR-NEXT: %[[outDesc:.*]] = llvm.insertvalue %[[c1]], %[[desc6]][4, 0] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> 130 %res = call @foo(%in) : (memref<10xi8>) -> (memref<20xi8>) 131 // BAREPTR-NEXT: %[[res:.*]] = llvm.extractvalue %[[outDesc]][1] : !llvm.struct<(ptr<i8>, ptr<i8>, i64, array<1 x i64>, array<1 x i64>)> 132 // BAREPTR-NEXT: llvm.return %[[res]] : !llvm.ptr<i8> 133 return %res : memref<20xi8> 134} 135 136// ----- 137 138// Unranked memrefs are currently not supported in the bare-ptr calling 139// convention. Check that the conversion to the LLVM-IR dialect doesn't happen 140// in the presence of unranked memrefs when using such a calling convention. 141 142// BAREPTR: func private @hoo(memref<*xi8>) -> memref<*xi8> 143func private @hoo(memref<*xi8>) -> memref<*xi8> 144 145// BAREPTR-LABEL: func @check_unranked_memref_func_call(%{{.*}}: memref<*xi8>) -> memref<*xi8> 146func @check_unranked_memref_func_call(%in: memref<*xi8>) -> memref<*xi8> { 147 // BAREPTR-NEXT: call @hoo(%{{.*}}) : (memref<*xi8>) -> memref<*xi8> 148 %res = call @hoo(%in) : (memref<*xi8>) -> memref<*xi8> 149 // BAREPTR-NEXT: return %{{.*}} : memref<*xi8> 150 return %res : memref<*xi8> 151} 152 153// ----- 154 155// Should not convert memrefs with unsupported types in any convention. 156 157// CHECK: @unsupported_memref_element_type 158// CHECK-SAME: memref< 159// CHECK-NOT: !llvm.struct 160// BAREPTR: @unsupported_memref_element_type 161// BAREPTR-SAME: memref< 162// BAREPTR-NOT: !llvm.ptr 163func private @unsupported_memref_element_type() -> memref<42 x !test.memref_element> 164 165// CHECK: @unsupported_unranked_memref_element_type 166// CHECK-SAME: memref< 167// CHECK-NOT: !llvm.struct 168// BAREPTR: @unsupported_unranked_memref_element_type 169// BAREPTR-SAME: memref< 170// BAREPTR-NOT: !llvm.ptr 171func private @unsupported_unranked_memref_element_type() -> memref<* x !test.memref_element> 172 173// ----- 174 175// BAREPTR: llvm.func @goo(f32) -> f32 176func private @goo(f32) -> f32 177 178// BAREPTR-LABEL: func @check_scalar_func_call 179// BAREPTR-SAME: %[[in:.*]]: f32) 180func @check_scalar_func_call(%in : f32) { 181 // BAREPTR-NEXT: %[[call:.*]] = llvm.call @goo(%[[in]]) : (f32) -> f32 182 %res = call @goo(%in) : (f32) -> (f32) 183 return 184} 185 186// ----- 187 188!base_type = type memref<64xi32, 201> 189 190// CHECK-LABEL: func @loop_carried 191// BAREPTR-LABEL: func @loop_carried 192func @loop_carried(%arg0 : index, %arg1 : index, %arg2 : index, %base0 : !base_type, %base1 : !base_type) -> (!base_type, !base_type) { 193 // This test checks that in the BAREPTR case, the branch arguments only forward the descriptor. 194 // This test was lowered from a simple scf.for that swaps 2 memref iter_args. 195 // BAREPTR: llvm.br ^bb1(%{{.*}}, %{{.*}}, %{{.*}} : i64, !llvm.struct<(ptr<i32, 201>, ptr<i32, 201>, i64, array<1 x i64>, array<1 x i64>)>, !llvm.struct<(ptr<i32, 201>, ptr<i32, 201>, i64, array<1 x i64>, array<1 x i64>)>) 196 br ^bb1(%arg0, %base0, %base1 : index, memref<64xi32, 201>, memref<64xi32, 201>) 197 198 // BAREPTR-NEXT: ^bb1 199 // BAREPTR-NEXT: llvm.icmp 200 // BAREPTR-NEXT: llvm.cond_br %{{.*}}, ^bb2, ^bb3 201 ^bb1(%0: index, %1: memref<64xi32, 201>, %2: memref<64xi32, 201>): // 2 preds: ^bb0, ^bb2 202 %3 = cmpi slt, %0, %arg1 : index 203 cond_br %3, ^bb2, ^bb3 204 ^bb2: // pred: ^bb1 205 %4 = addi %0, %arg2 : index 206 br ^bb1(%4, %2, %1 : index, memref<64xi32, 201>, memref<64xi32, 201>) 207 ^bb3: // pred: ^bb1 208 return %1, %2 : memref<64xi32, 201>, memref<64xi32, 201> 209} 210