1// RUN: mlir-opt -finalize-memref-to-llvm %s -split-input-file | FileCheck %s 2// RUN: mlir-opt -finalize-memref-to-llvm='index-bitwidth=32' %s -split-input-file | FileCheck --check-prefix=CHECK32 %s 3 4// Same below, but using the `ConvertToLLVMPatternInterface` entry point 5// and the generic `convert-to-llvm` pass. This produces slightly different IR 6// because the conversion target is set up differently. Only one test case is 7// checked. 8// RUN: mlir-opt --convert-to-llvm="filter-dialects=memref" --split-input-file %s | FileCheck --check-prefix=CHECK-INTERFACE %s 9 10// CHECK-LABEL: func @view( 11// CHECK: %[[ARG0F:.*]]: index, %[[ARG1F:.*]]: index, %[[ARG2F:.*]]: index 12func.func @view(%arg0 : index, %arg1 : index, %arg2 : index) { 13 // CHECK-DAG: %[[ARG2:.*]] = builtin.unrealized_conversion_cast %[[ARG2F]] 14 // CHECK-DAG: %[[ARG0:.*]] = builtin.unrealized_conversion_cast %[[ARG0F]] 15 // CHECK-DAG: %[[ARG1:.*]] = builtin.unrealized_conversion_cast %[[ARG1F]] 16 // CHECK: llvm.mlir.constant(2048 : index) : i64 17 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 18 %0 = memref.alloc() : memref<2048xi8> 19 20 // Test two dynamic sizes. 21 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 22 // CHECK: %[[BASE_PTR:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 23 // CHECK: %[[SHIFTED_BASE_PTR:.*]] = llvm.getelementptr %[[BASE_PTR]][%[[ARG2]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 24 // CHECK: llvm.insertvalue %[[SHIFTED_BASE_PTR]], %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 25 // CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64 26 // CHECK: llvm.insertvalue %[[C0]], %{{.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 27 // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 28 // CHECK: llvm.mlir.constant(1 : index) : i64 29 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 30 // CHECK: llvm.insertvalue %[[ARG0]], %{{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 31 // CHECK: llvm.mul %{{.*}}, %[[ARG1]] 32 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 33 %1 = memref.view %0[%arg2][%arg0, %arg1] : memref<2048xi8> to memref<?x?xf32> 34 35 // Test one dynamic size. 36 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 37 // CHECK: %[[BASE_PTR_2:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 38 // CHECK: %[[SHIFTED_BASE_PTR_2:.*]] = llvm.getelementptr %[[BASE_PTR_2]][%[[ARG2]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 39 // CHECK: llvm.insertvalue %[[SHIFTED_BASE_PTR_2]], %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 40 // CHECK: %[[C0_2:.*]] = llvm.mlir.constant(0 : index) : i64 41 // CHECK: llvm.insertvalue %[[C0_2]], %{{.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 42 // CHECK: llvm.insertvalue %[[ARG1]], %{{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 43 // CHECK: llvm.mlir.constant(1 : index) : i64 44 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 45 // CHECK: llvm.mlir.constant(4 : index) : i64 46 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 47 // CHECK: llvm.mul %{{.*}}, %[[ARG1]] 48 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 49 %3 = memref.view %0[%arg2][%arg1] : memref<2048xi8> to memref<4x?xf32> 50 51 // Test static sizes. 52 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 53 // CHECK: %[[BASE_PTR_3:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 54 // CHECK: %[[SHIFTED_BASE_PTR_3:.*]] = llvm.getelementptr %[[BASE_PTR_3]][%[[ARG2]]] : (!llvm.ptr, i64) -> !llvm.ptr, i8 55 // CHECK: llvm.insertvalue %[[SHIFTED_BASE_PTR_3]], %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 56 // CHECK: %[[C0_3:.*]] = llvm.mlir.constant(0 : index) : i64 57 // CHECK: llvm.insertvalue %[[C0_3]], %{{.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 58 // CHECK: llvm.mlir.constant(4 : index) : i64 59 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 60 // CHECK: llvm.mlir.constant(1 : index) : i64 61 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 62 // CHECK: llvm.mlir.constant(64 : index) : i64 63 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 64 // CHECK: llvm.mlir.constant(4 : index) : i64 65 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 66 %5 = memref.view %0[%arg2][] : memref<2048xi8> to memref<64x4xf32> 67 68 // Test view memory space. 69 // CHECK: llvm.mlir.constant(2048 : index) : i64 70 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<4>, ptr<4>, i64, array<1 x i64>, array<1 x i64>)> 71 %6 = memref.alloc() : memref<2048xi8, 4> 72 73 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<4>, ptr<4>, i64, array<2 x i64>, array<2 x i64>)> 74 // CHECK: %[[BASE_PTR_4:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr<4>, ptr<4>, i64, array<1 x i64>, array<1 x i64>)> 75 // CHECK: %[[SHIFTED_BASE_PTR_4:.*]] = llvm.getelementptr %[[BASE_PTR_4]][%[[ARG2]]] : (!llvm.ptr<4>, i64) -> !llvm.ptr<4>, i8 76 // CHECK: llvm.insertvalue %[[SHIFTED_BASE_PTR_4]], %{{.*}}[1] : !llvm.struct<(ptr<4>, ptr<4>, i64, array<2 x i64>, array<2 x i64>)> 77 // CHECK: %[[C0_4:.*]] = llvm.mlir.constant(0 : index) : i64 78 // CHECK: llvm.insertvalue %[[C0_4]], %{{.*}}[2] : !llvm.struct<(ptr<4>, ptr<4>, i64, array<2 x i64>, array<2 x i64>)> 79 // CHECK: llvm.mlir.constant(4 : index) : i64 80 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr<4>, ptr<4>, i64, array<2 x i64>, array<2 x i64>)> 81 // CHECK: llvm.mlir.constant(1 : index) : i64 82 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr<4>, ptr<4>, i64, array<2 x i64>, array<2 x i64>)> 83 // CHECK: llvm.mlir.constant(64 : index) : i64 84 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr<4>, ptr<4>, i64, array<2 x i64>, array<2 x i64>)> 85 // CHECK: llvm.mlir.constant(4 : index) : i64 86 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr<4>, ptr<4>, i64, array<2 x i64>, array<2 x i64>)> 87 %7 = memref.view %6[%arg2][] : memref<2048xi8, 4> to memref<64x4xf32, 4> 88 89 return 90} 91 92// ----- 93 94// CHECK-LABEL: func @view_empty_memref( 95// CHECK: %[[ARG0:.*]]: index, 96// CHECK: %[[ARG1:.*]]: memref<0xi8>) 97 98// CHECK-INTERFACE-LABEL: func @view_empty_memref( 99// CHECK-INTERFACE: %[[ARG0:.*]]: index, 100// CHECK-INTERFACE: %[[ARG1:.*]]: memref<0xi8>) 101func.func @view_empty_memref(%offset: index, %mem: memref<0xi8>) { 102 103 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 104 // CHECK: llvm.mlir.constant(0 : index) : i64 105 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 106 // CHECK: llvm.mlir.constant(4 : index) : i64 107 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 108 // CHECK: llvm.mlir.constant(1 : index) : i64 109 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 110 // CHECK: llvm.mlir.constant(0 : index) : i64 111 // CHECK: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 112 // CHECK: llvm.mlir.constant(4 : index) : i64 113 // CHECK: = llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 114 115 // CHECK-INTERFACE: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 116 // CHECK-INTERFACE: llvm.mlir.constant(0 : index) : i64 117 // CHECK-INTERFACE: llvm.insertvalue %{{.*}}, %{{.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 118 // CHECK-INTERFACE: llvm.mlir.constant(4 : index) : i64 119 // CHECK-INTERFACE: llvm.insertvalue %{{.*}}, %{{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 120 // CHECK-INTERFACE: llvm.mlir.constant(1 : index) : i64 121 // CHECK-INTERFACE: llvm.insertvalue %{{.*}}, %{{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 122 // CHECK-INTERFACE: llvm.mlir.constant(0 : index) : i64 123 // CHECK-INTERFACE: llvm.insertvalue %{{.*}}, %{{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 124 // CHECK-INTERFACE: llvm.mlir.constant(4 : index) : i64 125 // CHECK-INTERFACE: = llvm.insertvalue %{{.*}}, %{{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 126 %0 = memref.view %mem[%offset][] : memref<0xi8> to memref<0x4xf32> 127 128 return 129} 130 131// ----- 132 133// Subviews needs to be expanded outside of the memref-to-llvm pass. 134// CHECK-LABEL: func @subview( 135// CHECK: %[[MEMREF:.*]]: memref<{{.*}}>, 136// CHECK: %[[ARG0:[a-zA-Z0-9]*]]: index, 137// CHECK: %[[ARG1:[a-zA-Z0-9]*]]: index, 138// CHECK: %[[ARG2:.*]]: index) 139// CHECK32-LABEL: func @subview( 140// CHECK32: %[[MEMREF:.*]]: memref<{{.*}}>, 141// CHECK32: %[[ARG0:[a-zA-Z0-9]*]]: index, 142// CHECK32: %[[ARG1:[a-zA-Z0-9]*]]: index, 143// CHECK32: %[[ARG2:.*]]: index) 144func.func @subview(%0 : memref<64x4xf32, strided<[4, 1], offset: 0>>, %arg0 : index, %arg1 : index, %arg2 : index) { 145 // CHECK: memref.subview %[[MEMREF]][%[[ARG0]], %[[ARG1]]] [%[[ARG0]], %[[ARG1]]] 146 // CHECK32: memref.subview %[[MEMREF]][%[[ARG0]], %[[ARG1]]] [%[[ARG0]], %[[ARG1]]] [%[[ARG0]], %[[ARG1]]] 147 %1 = memref.subview %0[%arg0, %arg1][%arg0, %arg1][%arg0, %arg1] : 148 memref<64x4xf32, strided<[4, 1], offset: 0>> 149 to memref<?x?xf32, strided<[?, ?], offset: ?>> 150 return 151} 152 153// ----- 154 155// CHECK-LABEL: func @assume_alignment( 156func.func @assume_alignment(%0 : memref<4x4xf16>) { 157 // CHECK: %[[PTR:.*]] = llvm.extractvalue %[[MEMREF:.*]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 158 // CHECK-NEXT: %[[TRUE:.*]] = llvm.mlir.constant(true) : i1 159 // CHECK-NEXT: %[[ALIGN:.*]] = llvm.mlir.constant(16 : index) : i64 160 // CHECK-NEXT: llvm.intr.assume %[[TRUE]] ["align"(%[[PTR]], %[[ALIGN]] : !llvm.ptr, i64)] : i1 161 memref.assume_alignment %0, 16 : memref<4x4xf16> 162 return 163} 164 165// ----- 166 167// CHECK-LABEL: func @assume_alignment_w_offset 168func.func @assume_alignment_w_offset(%0 : memref<4x4xf16, strided<[?, ?], offset: ?>>) { 169 // CHECK-DAG: %[[PTR:.*]] = llvm.extractvalue %[[MEMREF:.*]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 170 // CHECK-DAG: %[[OFFSET:.*]] = llvm.extractvalue %[[MEMREF]][2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 171 // CHECK-DAG: %[[BUFF_ADDR:.*]] = llvm.getelementptr %[[PTR]][%[[OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, f16 172 // CHECK-DAG: %[[TRUE:.*]] = llvm.mlir.constant(true) : i1 173 // CHECK-DAG: %[[ALIGN:.*]] = llvm.mlir.constant(16 : index) : i64 174 // CHECK-NEXT: llvm.intr.assume %[[TRUE]] ["align"(%[[BUFF_ADDR]], %[[ALIGN]] : !llvm.ptr, i64)] : i1 175 memref.assume_alignment %0, 16 : memref<4x4xf16, strided<[?, ?], offset: ?>> 176 return 177} 178// ----- 179 180// CHECK-LABEL: func @dim_of_unranked 181// CHECK32-LABEL: func @dim_of_unranked 182func.func @dim_of_unranked(%unranked: memref<*xi32>) -> index { 183 %c0 = arith.constant 0 : index 184 %dim = memref.dim %unranked, %c0 : memref<*xi32> 185 return %dim : index 186} 187// CHECK: %[[UNRANKED_DESC:.*]] = builtin.unrealized_conversion_cast 188 189// CHECK: %[[RANKED_DESC:.*]] = llvm.extractvalue %[[UNRANKED_DESC]][1] 190// CHECK-SAME: : !llvm.struct<(i64, ptr)> 191 192// CHECK: %[[OFFSET_PTR:.*]] = llvm.getelementptr %[[RANKED_DESC]]{{\[}} 193// CHECK-SAME: 0, 2] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<(ptr, ptr, i64)> 194 195// CHECK: %[[C1:.*]] = llvm.mlir.constant(1 : index) : i64 196// CHECK: %[[INDEX_INC:.*]] = llvm.add %[[C1]], %{{.*}} : i64 197 198// CHECK: %[[SIZE_PTR:.*]] = llvm.getelementptr %[[OFFSET_PTR]]{{\[}} 199// CHECK-SAME: %[[INDEX_INC]]] : (!llvm.ptr, i64) -> !llvm.ptr 200 201// CHECK: %[[SIZE:.*]] = llvm.load %[[SIZE_PTR]] : !llvm.ptr -> i64 202 203// CHECK32: %[[SIZE:.*]] = llvm.load %{{.*}} : !llvm.ptr -> i32 204 205// ----- 206 207// CHECK-LABEL: func @address_space( 208func.func @address_space(%arg0 : memref<32xf32, affine_map<(d0) -> (d0)>, 7>) { 209 // CHECK: %[[MEMORY:.*]] = llvm.call @malloc(%{{.*}}) 210 // CHECK: %[[CAST:.*]] = llvm.addrspacecast %[[MEMORY]] : !llvm.ptr to !llvm.ptr<5> 211 // CHECK: llvm.insertvalue %[[CAST]], %{{[[:alnum:]]+}}[0] 212 // CHECK: llvm.insertvalue %[[CAST]], %{{[[:alnum:]]+}}[1] 213 %0 = memref.alloc() : memref<32xf32, affine_map<(d0) -> (d0)>, 5> 214 %1 = arith.constant 7 : index 215 // CHECK: llvm.load %{{.*}} : !llvm.ptr<5> -> f32 216 %2 = memref.load %0[%1] : memref<32xf32, affine_map<(d0) -> (d0)>, 5> 217 func.return 218} 219 220// ----- 221 222// CHECK-LABEL: func @transpose 223// CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 224// CHECK: llvm.insertvalue {{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 225// CHECK: llvm.insertvalue {{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 226// CHECK: llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 227// CHECK: llvm.extractvalue {{.*}}[3, 2] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 228// CHECK: llvm.insertvalue {{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 229// CHECK: llvm.extractvalue {{.*}}[4, 2] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 230// CHECK: llvm.insertvalue {{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 231// CHECK: llvm.extractvalue {{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 232// CHECK: llvm.insertvalue {{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 233// CHECK: llvm.extractvalue {{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 234// CHECK: llvm.insertvalue {{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 235// CHECK: llvm.extractvalue {{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 236// CHECK: llvm.insertvalue {{.*}}[3, 2] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 237// CHECK: llvm.extractvalue {{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 238// CHECK: llvm.insertvalue {{.*}}[4, 2] : !llvm.struct<(ptr, ptr, i64, array<3 x i64>, array<3 x i64>)> 239func.func @transpose(%arg0: memref<?x?x?xf32, strided<[?, ?, 1], offset: ?>>) { 240 %0 = memref.transpose %arg0 (i, j, k) -> (k, i, j) : memref<?x?x?xf32, strided<[?, ?, 1], offset: ?>> to memref<?x?x?xf32, strided<[1, ?, ?], offset: ?>> 241 return 242} 243 244// ----- 245 246// CHECK: llvm.mlir.global external @gv0() {addr_space = 0 : i32} : !llvm.array<2 x f32> { 247// CHECK-NEXT: %0 = llvm.mlir.undef : !llvm.array<2 x f32> 248// CHECK-NEXT: llvm.return %0 : !llvm.array<2 x f32> 249// CHECK-NEXT: } 250memref.global @gv0 : memref<2xf32> = uninitialized 251 252// CHECK: llvm.mlir.global private @gv1() {addr_space = 0 : i32} : !llvm.array<2 x f32> 253memref.global "private" @gv1 : memref<2xf32> 254 255// 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>) {addr_space = 0 : i32} : !llvm.array<2 x array<3 x f32>> 256memref.global @gv2 : memref<2x3xf32> = dense<[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0]]> 257 258// Test 1D memref. 259// CHECK-LABEL: func @get_gv0_memref 260func.func @get_gv0_memref() { 261 %0 = memref.get_global @gv0 : memref<2xf32> 262 // CHECK: %[[DIM:.*]] = llvm.mlir.constant(2 : index) : i64 263 // CHECK: %[[STRIDE:.*]] = llvm.mlir.constant(1 : index) : i64 264 // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv0 : !llvm.ptr 265 // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<2 x f32> 266 // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64 267 // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr 268 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 269 // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 270 // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 271 // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64 272 // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 273 // CHECK: llvm.insertvalue %[[DIM]], {{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 274 // CHECK: llvm.insertvalue %[[STRIDE]], {{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 275 return 276} 277 278// Test 2D memref. 279// CHECK-LABEL: func @get_gv2_memref 280func.func @get_gv2_memref() { 281 // CHECK: %[[DIM0:.*]] = llvm.mlir.constant(2 : index) : i64 282 // CHECK: %[[DIM1:.*]] = llvm.mlir.constant(3 : index) : i64 283 // CHECK: %[[STRIDE1:.*]] = llvm.mlir.constant(1 : index) : i64 284 // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv2 : !llvm.ptr 285 // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][0, 0, 0] : (!llvm.ptr) -> !llvm.ptr, !llvm.array<2 x array<3 x f32>> 286 // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64 287 // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr 288 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 289 // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 290 // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 291 // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64 292 // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 293 // CHECK: llvm.insertvalue %[[DIM0]], {{.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 294 // CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 295 // CHECK: llvm.insertvalue %[[DIM1]], {{.*}}[4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 296 // CHECK: llvm.insertvalue %[[STRIDE1]], {{.*}}[4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 297 298 %0 = memref.get_global @gv2 : memref<2x3xf32> 299 return 300} 301 302// Test scalar memref. 303// CHECK: llvm.mlir.global external @gv3(1.000000e+00 : f32) {addr_space = 0 : i32} : f32 304memref.global @gv3 : memref<f32> = dense<1.0> 305 306// CHECK-LABEL: func @get_gv3_memref 307func.func @get_gv3_memref() { 308 // CHECK: %[[ADDR:.*]] = llvm.mlir.addressof @gv3 : !llvm.ptr 309 // CHECK: %[[GEP:.*]] = llvm.getelementptr %[[ADDR]][0] : (!llvm.ptr) -> !llvm.ptr, f32 310 // CHECK: %[[DEADBEEF:.*]] = llvm.mlir.constant(3735928559 : index) : i64 311 // CHECK: %[[DEADBEEFPTR:.*]] = llvm.inttoptr %[[DEADBEEF]] : i64 to !llvm.ptr 312 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64)> 313 // CHECK: llvm.insertvalue %[[DEADBEEFPTR]], {{.*}}[0] : !llvm.struct<(ptr, ptr, i64)> 314 // CHECK: llvm.insertvalue %[[GEP]], {{.*}}[1] : !llvm.struct<(ptr, ptr, i64)> 315 // CHECK: %[[OFFSET:.*]] = llvm.mlir.constant(0 : index) : i64 316 // CHECK: llvm.insertvalue %[[OFFSET]], {{.*}}[2] : !llvm.struct<(ptr, ptr, i64)> 317 %0 = memref.get_global @gv3 : memref<f32> 318 return 319} 320 321// Test scalar memref with an alignment. 322// CHECK: llvm.mlir.global private @gv4(1.000000e+00 : f32) {addr_space = 0 : i32, alignment = 64 : i64} : f32 323memref.global "private" @gv4 : memref<f32> = dense<1.0> {alignment = 64} 324 325// ----- 326 327// Expand shapes need to be expanded outside of the memref-to-llvm pass. 328// CHECK-LABEL: func @expand_shape_static( 329// CHECK-SAME: %[[ARG:.*]]: memref<{{.*}}>) 330func.func @expand_shape_static(%arg0: memref<3x4x5xf32>) -> memref<1x3x4x1x5xf32> { 331 // CHECK: memref.expand_shape %[[ARG]] {{\[}}[0, 1], [2], [3, 4]] output_shape [1, 3, 4, 1, 5] 332 // Reshapes that expand a contiguous tensor with some 1's. 333 %0 = memref.expand_shape %arg0 [[0, 1], [2], [3, 4]] output_shape [1, 3, 4, 1, 5] 334 : memref<3x4x5xf32> into memref<1x3x4x1x5xf32> 335 return %0 : memref<1x3x4x1x5xf32> 336} 337 338// ----- 339 340// Collapse shapes need to be expanded outside of the memref-to-llvm pass. 341// CHECK-LABEL: func @collapse_shape_static 342// CHECK-SAME: %[[ARG:.*]]: memref<1x3x4x1x5xf32>) -> memref<3x4x5xf32> { 343func.func @collapse_shape_static(%arg0: memref<1x3x4x1x5xf32>) -> memref<3x4x5xf32> { 344 %0 = memref.collapse_shape %arg0 [[0, 1], [2], [3, 4]] : 345 memref<1x3x4x1x5xf32> into memref<3x4x5xf32> 346 return %0 : memref<3x4x5xf32> 347} 348 349// ----- 350 351// CHECK-LABEL: func @rank_of_unranked 352// CHECK32-LABEL: func @rank_of_unranked 353func.func @rank_of_unranked(%unranked: memref<*xi32>) { 354 %rank = memref.rank %unranked : memref<*xi32> 355 return 356} 357// CHECK: %[[UNRANKED_DESC:.*]] = builtin.unrealized_conversion_cast 358// CHECK-NEXT: llvm.extractvalue %[[UNRANKED_DESC]][0] : !llvm.struct<(i64, ptr)> 359// CHECK32: llvm.extractvalue %{{.*}}[0] : !llvm.struct<(i32, ptr)> 360 361// CHECK-LABEL: func @rank_of_ranked 362// CHECK32-LABEL: func @rank_of_ranked 363func.func @rank_of_ranked(%ranked: memref<?xi32>) { 364 %rank = memref.rank %ranked : memref<?xi32> 365 return 366} 367// CHECK: llvm.mlir.constant(1 : index) : i64 368// CHECK32: llvm.mlir.constant(1 : index) : i32 369 370// ----- 371 372// CHECK-LABEL: func @atomic_rmw 373func.func @atomic_rmw(%I : memref<10xi32>, %ival : i32, %F : memref<10xf32>, %fval : f32, %i : index) { 374 memref.atomic_rmw assign %fval, %F[%i] : (f32, memref<10xf32>) -> f32 375 // CHECK: llvm.atomicrmw xchg %{{.*}}, %{{.*}} acq_rel 376 memref.atomic_rmw addi %ival, %I[%i] : (i32, memref<10xi32>) -> i32 377 // CHECK: llvm.atomicrmw add %{{.*}}, %{{.*}} acq_rel 378 memref.atomic_rmw maxs %ival, %I[%i] : (i32, memref<10xi32>) -> i32 379 // CHECK: llvm.atomicrmw max %{{.*}}, %{{.*}} acq_rel 380 memref.atomic_rmw mins %ival, %I[%i] : (i32, memref<10xi32>) -> i32 381 // CHECK: llvm.atomicrmw min %{{.*}}, %{{.*}} acq_rel 382 memref.atomic_rmw maxu %ival, %I[%i] : (i32, memref<10xi32>) -> i32 383 // CHECK: llvm.atomicrmw umax %{{.*}}, %{{.*}} acq_rel 384 memref.atomic_rmw minu %ival, %I[%i] : (i32, memref<10xi32>) -> i32 385 // CHECK: llvm.atomicrmw umin %{{.*}}, %{{.*}} acq_rel 386 memref.atomic_rmw addf %fval, %F[%i] : (f32, memref<10xf32>) -> f32 387 // CHECK: llvm.atomicrmw fadd %{{.*}}, %{{.*}} acq_rel 388 memref.atomic_rmw ori %ival, %I[%i] : (i32, memref<10xi32>) -> i32 389 // CHECK: llvm.atomicrmw _or %{{.*}}, %{{.*}} acq_rel 390 memref.atomic_rmw andi %ival, %I[%i] : (i32, memref<10xi32>) -> i32 391 // CHECK: llvm.atomicrmw _and %{{.*}}, %{{.*}} acq_rel 392 return 393} 394 395// ----- 396 397func.func @atomic_rmw_with_offset(%I : memref<10xi32, strided<[1], offset: 5>>, %ival : i32, %i : index) { 398 memref.atomic_rmw andi %ival, %I[%i] : (i32, memref<10xi32, strided<[1], offset: 5>>) -> i32 399 return 400} 401// CHECK-LABEL: func @atomic_rmw_with_offset 402// CHECK-SAME: %[[ARG0:.+]]: memref<10xi32, strided<[1], offset: 5>> 403// CHECK-SAME: %[[ARG1:.+]]: i32 404// CHECK-SAME: %[[ARG2:.+]]: index 405// CHECK-DAG: %[[MEMREF_STRUCT:.+]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<10xi32, strided<[1], offset: 5>> to !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 406// CHECK-DAG: %[[INDEX:.+]] = builtin.unrealized_conversion_cast %[[ARG2]] : index to i64 407// CHECK: %[[BASE_PTR:.+]] = llvm.extractvalue %[[MEMREF_STRUCT]][1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 408// CHECK: %[[OFFSET:.+]] = llvm.mlir.constant(5 : index) : i64 409// CHECK: %[[OFFSET_PTR:.+]] = llvm.getelementptr %[[BASE_PTR]][%[[OFFSET]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 410// CHECK: %[[PTR:.+]] = llvm.getelementptr %[[OFFSET_PTR]][%[[INDEX]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 411// CHECK: llvm.atomicrmw _and %[[PTR]], %[[ARG1]] acq_rel 412 413// ----- 414 415// CHECK-LABEL: func @generic_atomic_rmw 416func.func @generic_atomic_rmw(%I : memref<10xi32>, %i : index) { 417 %x = memref.generic_atomic_rmw %I[%i] : memref<10xi32> { 418 ^bb0(%old_value : i32): 419 memref.atomic_yield %old_value : i32 420 } 421 llvm.return 422} 423// CHECK: %[[INIT:.*]] = llvm.load %{{.*}} : !llvm.ptr -> i32 424// CHECK-NEXT: llvm.br ^bb1(%[[INIT]] : i32) 425// CHECK-NEXT: ^bb1(%[[LOADED:.*]]: i32): 426// CHECK-NEXT: %[[PAIR:.*]] = llvm.cmpxchg %{{.*}}, %[[LOADED]], %[[LOADED]] 427// CHECK-SAME: acq_rel monotonic : !llvm.ptr, i32 428// CHECK-NEXT: %[[NEW:.*]] = llvm.extractvalue %[[PAIR]][0] 429// CHECK-NEXT: %[[OK:.*]] = llvm.extractvalue %[[PAIR]][1] 430// CHECK-NEXT: llvm.cond_br %[[OK]], ^bb2, ^bb1(%[[NEW]] : i32) 431 432// ----- 433 434// CHECK-LABEL: func @generic_atomic_rmw_in_alloca_scope 435func.func @generic_atomic_rmw_in_alloca_scope(){ 436 %c1 = arith.constant 1 : index 437 %alloc = memref.alloc() : memref<2x3xi32> 438 memref.alloca_scope { 439 %0 = memref.generic_atomic_rmw %alloc[%c1, %c1] : memref<2x3xi32> { 440 ^bb0(%arg0: i32): 441 memref.atomic_yield %arg0 : i32 442 } 443 } 444 return 445} 446// CHECK: %[[STACK_SAVE:.*]] = llvm.intr.stacksave : !llvm.ptr 447// CHECK-NEXT: llvm.br ^bb1 448// CHECK: ^bb1: 449// CHECK: %[[INIT:.*]] = llvm.load %[[BUF:.*]] : !llvm.ptr -> i32 450// CHECK-NEXT: llvm.br ^bb2(%[[INIT]] : i32) 451// CHECK-NEXT: ^bb2(%[[LOADED:.*]]: i32): 452// CHECK-NEXT: %[[PAIR:.*]] = llvm.cmpxchg %[[BUF]], %[[LOADED]], %[[LOADED]] 453// CHECK-SAME: acq_rel monotonic : !llvm.ptr, i32 454// CHECK-NEXT: %[[NEW:.*]] = llvm.extractvalue %[[PAIR]][0] 455// CHECK-NEXT: %[[OK:.*]] = llvm.extractvalue %[[PAIR]][1] 456// CHECK-NEXT: llvm.cond_br %[[OK]], ^bb3, ^bb2(%[[NEW]] : i32) 457// CHECK-NEXT: ^bb3: 458// CHECK-NEXT: llvm.intr.stackrestore %[[STACK_SAVE]] : !llvm.ptr 459// CHECK-NEXT: llvm.br ^bb4 460// CHECK-NEXT: ^bb4: 461// CHECK-NEXT: return 462 463// ----- 464 465// CHECK-LABEL: func @memref_copy_ranked 466func.func @memref_copy_ranked() { 467 %0 = memref.alloc() : memref<2xf32> 468 // CHECK: llvm.mlir.constant(2 : index) : i64 469 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 470 %1 = memref.cast %0 : memref<2xf32> to memref<?xf32> 471 %2 = memref.alloc() : memref<2xf32> 472 // CHECK: llvm.mlir.constant(2 : index) : i64 473 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 474 %3 = memref.cast %2 : memref<2xf32> to memref<?xf32> 475 memref.copy %1, %3 : memref<?xf32> to memref<?xf32> 476 // CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : index) : i64 477 // CHECK: [[EXTRACT0:%.*]] = llvm.extractvalue {{%.*}}[3, 0] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 478 // CHECK: [[MUL:%.*]] = llvm.mul [[ONE]], [[EXTRACT0]] : i64 479 // CHECK: [[NULL:%.*]] = llvm.mlir.zero : !llvm.ptr 480 // CHECK: [[GEP:%.*]] = llvm.getelementptr [[NULL]][1] : (!llvm.ptr) -> !llvm.ptr, f32 481 // CHECK: [[PTRTOINT:%.*]] = llvm.ptrtoint [[GEP]] : !llvm.ptr to i64 482 // CHECK: [[SIZE:%.*]] = llvm.mul [[MUL]], [[PTRTOINT]] : i64 483 // CHECK: [[EXTRACT1P:%.*]] = llvm.extractvalue {{%.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 484 // CHECK: [[EXTRACT1O:%.*]] = llvm.extractvalue {{%.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 485 // CHECK: [[GEP1:%.*]] = llvm.getelementptr [[EXTRACT1P]][[[EXTRACT1O]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32 486 // CHECK: [[EXTRACT2P:%.*]] = llvm.extractvalue {{%.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 487 // CHECK: [[EXTRACT2O:%.*]] = llvm.extractvalue {{%.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 488 // CHECK: [[GEP2:%.*]] = llvm.getelementptr [[EXTRACT2P]][[[EXTRACT2O]]] : (!llvm.ptr, i64) -> !llvm.ptr, f32 489 // CHECK: "llvm.intr.memcpy"([[GEP2]], [[GEP1]], [[SIZE]]) <{isVolatile = false}> 490 return 491} 492 493 494// ----- 495 496// CHECK-LABEL: func @memref_copy_contiguous 497func.func @memref_copy_contiguous(%in: memref<16x4xi32>, %offset: index) { 498 %buf = memref.alloc() : memref<1x2xi32> 499 %sub = memref.subview %in[%offset, 0] [1, 2] [1, 1] : memref<16x4xi32> to memref<1x2xi32, strided<[4, 1], offset: ?>> 500 memref.copy %sub, %buf : memref<1x2xi32, strided<[4, 1], offset: ?>> to memref<1x2xi32> 501 // Skip the memref descriptor of the alloc. 502 // CHECK: llvm.insertvalue {{%.*}}, {{%.*}}[4, 1] 503 // Get the memref for the subview. 504 // CHECK: %[[SUBVIEW:.*]] = memref.subview %{{.*}}[%{{.*}}, 0] [1, 2] [1, 1] : memref<16x4xi32> to memref<1x2xi32, strided<[4, 1], offset: ?>> 505 // CHECK: %[[DESC:.*]] = builtin.unrealized_conversion_cast %[[SUBVIEW]] : memref<1x2xi32, strided<[4, 1], offset: ?>> to !llvm.struct<(ptr 506 // CHECK: [[EXTRACT0:%.*]] = llvm.extractvalue %[[DESC]][3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 507 // CHECK: [[MUL1:%.*]] = llvm.mul {{.*}}, [[EXTRACT0]] : i64 508 // CHECK: [[EXTRACT1:%.*]] = llvm.extractvalue %[[DESC]][3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 509 // CHECK: [[MUL2:%.*]] = llvm.mul [[MUL1]], [[EXTRACT1]] : i64 510 // CHECK: [[NULL:%.*]] = llvm.mlir.zero : !llvm.ptr 511 // CHECK: [[GEP:%.*]] = llvm.getelementptr [[NULL]][1] : (!llvm.ptr) -> !llvm.ptr, i32 512 // CHECK: [[PTRTOINT:%.*]] = llvm.ptrtoint [[GEP]] : !llvm.ptr to i64 513 // CHECK: [[SIZE:%.*]] = llvm.mul [[MUL2]], [[PTRTOINT]] : i64 514 // CHECK: [[EXTRACT1P:%.*]] = llvm.extractvalue {{%.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 515 // CHECK: [[EXTRACT1O:%.*]] = llvm.extractvalue {{%.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 516 // CHECK: [[GEP1:%.*]] = llvm.getelementptr [[EXTRACT1P]][[[EXTRACT1O]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 517 // CHECK: [[EXTRACT2P:%.*]] = llvm.extractvalue {{%.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 518 // CHECK: [[EXTRACT2O:%.*]] = llvm.extractvalue {{%.*}}[2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 519 // CHECK: [[GEP2:%.*]] = llvm.getelementptr [[EXTRACT2P]][[[EXTRACT2O]]] : (!llvm.ptr, i64) -> !llvm.ptr, i32 520 // CHECK: "llvm.intr.memcpy"([[GEP2]], [[GEP1]], [[SIZE]]) <{isVolatile = false}> 521 return 522} 523 524// ----- 525 526// CHECK-LABEL: func @memref_copy_0d_offset 527func.func @memref_copy_0d_offset(%in: memref<2xi32>) { 528 %buf = memref.alloc() : memref<i32> 529 %sub = memref.subview %in[1] [1] [1] : memref<2xi32> to memref<1xi32, strided<[1], offset: 1>> 530 %scalar = memref.collapse_shape %sub [] : memref<1xi32, strided<[1], offset: 1>> into memref<i32, strided<[], offset: 1>> 531 memref.copy %scalar, %buf : memref<i32, strided<[], offset: 1>> to memref<i32> 532 // CHECK: llvm.intr.memcpy 533 return 534} 535 536// ----- 537 538// CHECK-LABEL: func @memref_copy_noncontiguous 539func.func @memref_copy_noncontiguous(%in: memref<16x2xi32>, %offset: index) { 540 %buf = memref.alloc() : memref<2x1xi32> 541 %sub = memref.subview %in[%offset, 0] [2, 1] [1, 1] : memref<16x2xi32> to memref<2x1xi32, strided<[2, 1], offset: ?>> 542 memref.copy %sub, %buf : memref<2x1xi32, strided<[2, 1], offset: ?>> to memref<2x1xi32> 543 // CHECK: llvm.call @memrefCopy 544 return 545} 546 547// ----- 548 549// CHECK-LABEL: func @memref_copy_unranked 550func.func @memref_copy_unranked() { 551 %0 = memref.alloc() : memref<2xi1> 552 // CHECK: llvm.mlir.constant(2 : index) : i64 553 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 554 %1 = memref.cast %0 : memref<2xi1> to memref<*xi1> 555 %2 = memref.alloc() : memref<2xi1> 556 // CHECK: llvm.mlir.constant(2 : index) : i64 557 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 558 %3 = memref.cast %2 : memref<2xi1> to memref<*xi1> 559 memref.copy %1, %3 : memref<*xi1> to memref<*xi1> 560 // CHECK: [[ONE:%.*]] = llvm.mlir.constant(1 : index) : i64 561 // CHECK: [[ALLOCA:%.*]] = llvm.alloca [[ONE]] x !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> : (i64) -> !llvm.ptr 562 // CHECK: llvm.store {{%.*}}, [[ALLOCA]] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)>, !llvm.ptr 563 // CHECK: [[RANK:%.*]] = llvm.mlir.constant(1 : index) : i64 564 // CHECK: [[UNDEF:%.*]] = llvm.mlir.undef : !llvm.struct<(i64, ptr)> 565 // CHECK: [[INSERT:%.*]] = llvm.insertvalue [[RANK]], [[UNDEF]][0] : !llvm.struct<(i64, ptr)> 566 // CHECK: [[INSERT2:%.*]] = llvm.insertvalue [[ALLOCA]], [[INSERT]][1] : !llvm.struct<(i64, ptr)> 567 // CHECK: [[STACKSAVE:%.*]] = llvm.intr.stacksave : !llvm.ptr 568 // CHECK: [[RANK2:%.*]] = llvm.mlir.constant(1 : index) : i64 569 // CHECK: [[ALLOCA2:%.*]] = llvm.alloca [[RANK2]] x !llvm.struct<(i64, ptr)> : (i64) -> !llvm.ptr 570 // CHECK: llvm.store {{%.*}}, [[ALLOCA2]] : !llvm.struct<(i64, ptr)>, !llvm.ptr 571 // CHECK: [[ALLOCA3:%.*]] = llvm.alloca [[RANK2]] x !llvm.struct<(i64, ptr)> : (i64) -> !llvm.ptr 572 // CHECK: llvm.store [[INSERT2]], [[ALLOCA3]] : !llvm.struct<(i64, ptr)>, !llvm.ptr 573 // CHECK: [[SIZEPTR:%.*]] = llvm.getelementptr {{%.*}}[1] : (!llvm.ptr) -> !llvm.ptr, i1 574 // CHECK: [[SIZE:%.*]] = llvm.ptrtoint [[SIZEPTR]] : !llvm.ptr to i64 575 // CHECK: llvm.call @memrefCopy([[SIZE]], [[ALLOCA2]], [[ALLOCA3]]) : (i64, !llvm.ptr, !llvm.ptr) -> () 576 // CHECK: llvm.intr.stackrestore [[STACKSAVE]] 577 return 578} 579 580// ----- 581 582// CHECK-LABEL: func @extract_aligned_pointer_as_index 583func.func @extract_aligned_pointer_as_index(%m: memref<?xf32>) -> index { 584 %0 = memref.extract_aligned_pointer_as_index %m: memref<?xf32> -> index 585 // CHECK: %[[E:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(ptr, ptr, i64, array<1 x i64>, array<1 x i64>)> 586 // CHECK: %[[I64:.*]] = llvm.ptrtoint %[[E]] : !llvm.ptr to i64 587 // CHECK: %[[R:.*]] = builtin.unrealized_conversion_cast %[[I64]] : i64 to index 588 589 // CHECK: return %[[R:.*]] : index 590 return %0: index 591} 592 593// ----- 594 595// CHECK-LABEL: func @extract_aligned_pointer_as_index_unranked 596func.func @extract_aligned_pointer_as_index_unranked(%m: memref<*xf32>) -> index { 597 %0 = memref.extract_aligned_pointer_as_index %m: memref<*xf32> -> index 598 // CHECK: %[[PTR:.*]] = llvm.extractvalue %{{.*}}[1] : !llvm.struct<(i64, ptr)> 599 // CHECK: %[[ALIGNED_FIELD:.*]] = llvm.getelementptr %[[PTR]][1] : (!llvm.ptr) -> !llvm.ptr, !llvm.ptr 600 // CHECK: %[[ALIGNED_PTR:.*]] = llvm.load %[[ALIGNED_FIELD]] : !llvm.ptr -> !llvm.ptr 601 // CHECK: %[[I64:.*]] = llvm.ptrtoint %[[ALIGNED_PTR]] : !llvm.ptr to i64 602 // CHECK: %[[R:.*]] = builtin.unrealized_conversion_cast %[[I64]] : i64 to index 603 604 // CHECK: return %[[R]] : index 605 return %0: index 606} 607 608// ----- 609 610// CHECK-LABEL: func @extract_strided_metadata( 611// CHECK-SAME: %[[ARG:.*]]: memref 612// CHECK: %[[MEM_DESC:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : memref<?x?xf32, strided<[?, ?], offset: ?>> to !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 613// CHECK: %[[BASE:.*]] = llvm.extractvalue %[[MEM_DESC]][0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 614// CHECK: %[[ALIGNED_BASE:.*]] = llvm.extractvalue %[[MEM_DESC]][1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 615// CHECK: %[[DESC:.*]] = llvm.mlir.undef : !llvm.struct<(ptr, ptr, i64)> 616// CHECK: %[[DESC0:.*]] = llvm.insertvalue %[[BASE]], %[[DESC]][0] : !llvm.struct<(ptr, ptr, i64)> 617// CHECK: %[[DESC1:.*]] = llvm.insertvalue %[[ALIGNED_BASE]], %[[DESC0]][1] : !llvm.struct<(ptr, ptr, i64)> 618// CHECK: %[[OFF0:.*]] = llvm.mlir.constant(0 : index) : i64 619// CHECK: %[[BASE_BUFFER_DESC:.*]] = llvm.insertvalue %[[OFF0]], %[[DESC1]][2] : !llvm.struct<(ptr, ptr, i64)> 620// CHECK: %[[OFFSET:.*]] = llvm.extractvalue %[[MEM_DESC]][2] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 621// CHECK: %[[SIZE0:.*]] = llvm.extractvalue %[[MEM_DESC]][3, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 622// CHECK: %[[SIZE1:.*]] = llvm.extractvalue %[[MEM_DESC]][3, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 623// CHECK: %[[STRIDE0:.*]] = llvm.extractvalue %[[MEM_DESC]][4, 0] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 624// CHECK: %[[STRIDE1:.*]] = llvm.extractvalue %[[MEM_DESC]][4, 1] : !llvm.struct<(ptr, ptr, i64, array<2 x i64>, array<2 x i64>)> 625func.func @extract_strided_metadata( 626 %ref: memref<?x?xf32, strided<[?,?], offset: ?>>) { 627 628 %base, %offset, %sizes:2, %strides:2 = 629 memref.extract_strided_metadata %ref : memref<?x?xf32, strided<[?,?], offset: ?>> 630 -> memref<f32>, index, 631 index, index, 632 index, index 633 634 return 635} 636 637// ----- 638 639// CHECK-LABEL: func @load_non_temporal( 640func.func @load_non_temporal(%arg0 : memref<32xf32, affine_map<(d0) -> (d0)>>) { 641 %1 = arith.constant 7 : index 642 // CHECK: llvm.load %{{.*}} {nontemporal} : !llvm.ptr -> f32 643 %2 = memref.load %arg0[%1] {nontemporal = true} : memref<32xf32, affine_map<(d0) -> (d0)>> 644 func.return 645} 646 647// ----- 648 649// CHECK-LABEL: func @store_non_temporal( 650func.func @store_non_temporal(%input : memref<32xf32, affine_map<(d0) -> (d0)>>, %output : memref<32xf32, affine_map<(d0) -> (d0)>>) { 651 %1 = arith.constant 7 : index 652 %2 = memref.load %input[%1] {nontemporal = true} : memref<32xf32, affine_map<(d0) -> (d0)>> 653 // CHECK: llvm.store %{{.*}}, %{{.*}} {nontemporal} : f32, !llvm.ptr 654 memref.store %2, %output[%1] {nontemporal = true} : memref<32xf32, affine_map<(d0) -> (d0)>> 655 func.return 656} 657