803 lines · plain
1// RUN: mlir-opt --split-input-file -pass-pipeline="builtin.module(convert-memref-to-spirv{bool-num-bits=8}, cse)" %s | FileCheck %s2// RUN: mlir-opt --split-input-file -pass-pipeline="builtin.module(convert-memref-to-spirv{bool-num-bits=8 use-64bit-index=true}, cse)" %s \3// RUN: | FileCheck --check-prefix=CHECK64 %s4 5// Check that with proper compute and storage extensions, we don't need to6// perform special tricks.7 8module attributes {9 spirv.target_env = #spirv.target_env<10 #spirv.vce<v1.5,11 [12 Shader, Int8, Int16, Int64, Float16, Float64,13 StorageBuffer16BitAccess, StorageUniform16, StoragePushConstant16,14 StorageBuffer8BitAccess, UniformAndStorageBuffer8BitAccess, StoragePushConstant8,15 PhysicalStorageBufferAddresses16 ],17 [SPV_KHR_16bit_storage, SPV_KHR_8bit_storage, SPV_KHR_storage_buffer_storage_class, SPV_KHR_physical_storage_buffer]>,18 #spirv.resource_limits<>>19} {20 21// CHECK-LABEL: @load_store_zero_rank_float(22// CHECK-SAME: %[[OARG0:.*]]: memref{{.*}}, %[[OARG1:.*]]: memref23func.func @load_store_zero_rank_float(%arg0: memref<f32, #spirv.storage_class<StorageBuffer>>, %arg1: memref<f32, #spirv.storage_class<StorageBuffer>>) {24 // CHECK-DAG: [[ARG0:%.*]] = builtin.unrealized_conversion_cast %[[OARG0]] : memref<f32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<1 x f32, stride=4> [0])>, StorageBuffer>25 // CHECK-DAG: [[ARG1:%.*]] = builtin.unrealized_conversion_cast %[[OARG1]] : memref<f32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<1 x f32, stride=4> [0])>, StorageBuffer>26 // CHECK: [[ZERO:%.*]] = spirv.Constant 0 : i3227 // CHECK: spirv.AccessChain [[ARG0]][28 // CHECK-SAME: [[ZERO]], [[ZERO]]29 // CHECK-SAME: ] :30 // CHECK: spirv.Load "StorageBuffer" %{{.*}} : f3231 %0 = memref.load %arg0[] : memref<f32, #spirv.storage_class<StorageBuffer>>32 // CHECK: spirv.AccessChain [[ARG1]][33 // CHECK-SAME: [[ZERO]], [[ZERO]]34 // CHECK-SAME: ] :35 // CHECK: spirv.Store "StorageBuffer" %{{.*}} : f3236 memref.store %0, %arg1[] : memref<f32, #spirv.storage_class<StorageBuffer>>37 return38}39 40// CHECK-LABEL: @load_store_zero_rank_int41// CHECK-SAME: %[[OARG0:.*]]: memref{{.*}}, %[[OARG1:.*]]: memref42func.func @load_store_zero_rank_int(%arg0: memref<i32, #spirv.storage_class<StorageBuffer>>, %arg1: memref<i32, #spirv.storage_class<StorageBuffer>>) {43 // CHECK-DAG: [[ARG0:%.*]] = builtin.unrealized_conversion_cast %[[OARG0]] : memref<i32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<1 x i32, stride=4> [0])>, StorageBuffer>44 // CHECK-DAG: [[ARG1:%.*]] = builtin.unrealized_conversion_cast %[[OARG1]] : memref<i32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<1 x i32, stride=4> [0])>, StorageBuffer>45 // CHECK: [[ZERO:%.*]] = spirv.Constant 0 : i3246 // CHECK: spirv.AccessChain [[ARG0]][47 // CHECK-SAME: [[ZERO]], [[ZERO]]48 // CHECK-SAME: ] :49 // CHECK: spirv.Load "StorageBuffer" %{{.*}} : i3250 %0 = memref.load %arg0[] : memref<i32, #spirv.storage_class<StorageBuffer>>51 // CHECK: spirv.AccessChain [[ARG1]][52 // CHECK-SAME: [[ZERO]], [[ZERO]]53 // CHECK-SAME: ] :54 // CHECK: spirv.Store "StorageBuffer" %{{.*}} : i3255 memref.store %0, %arg1[] : memref<i32, #spirv.storage_class<StorageBuffer>>56 return57}58 59// CHECK-LABEL: func @load_store_unknown_dim60// CHECK-SAME: %[[OARG0:.*]]: index, %[[OARG1:.*]]: memref{{.*}}, %[[OARG2:.*]]: memref61func.func @load_store_unknown_dim(%i: index, %source: memref<?xi32, #spirv.storage_class<StorageBuffer>>, %dest: memref<?xi32, #spirv.storage_class<StorageBuffer>>) {62 // CHECK-DAG: %[[SRC:.+]] = builtin.unrealized_conversion_cast %[[OARG1]] : memref<?xi32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.rtarray<i32, stride=4> [0])>, StorageBuffer>63 // CHECK-DAG: %[[DST:.+]] = builtin.unrealized_conversion_cast %[[OARG2]] : memref<?xi32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.rtarray<i32, stride=4> [0])>, StorageBuffer>64 // CHECK: %[[AC0:.+]] = spirv.AccessChain %[[SRC]]65 // CHECK: spirv.Load "StorageBuffer" %[[AC0]]66 %0 = memref.load %source[%i] : memref<?xi32, #spirv.storage_class<StorageBuffer>>67 // CHECK: %[[AC1:.+]] = spirv.AccessChain %[[DST]]68 // CHECK: spirv.Store "StorageBuffer" %[[AC1]]69 memref.store %0, %dest[%i]: memref<?xi32, #spirv.storage_class<StorageBuffer>>70 return71}72 73// CHECK-LABEL: func @load_i174// CHECK-SAME: (%[[SRC:.+]]: memref<4xi1, #spirv.storage_class<StorageBuffer>>, %[[IDX:.+]]: index)75func.func @load_i1(%src: memref<4xi1, #spirv.storage_class<StorageBuffer>>, %i : index) -> i1 {76 // CHECK-DAG: %[[SRC_CAST:.+]] = builtin.unrealized_conversion_cast %[[SRC]] : memref<4xi1, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<4 x i8, stride=1> [0])>, StorageBuffer>77 // CHECK-DAG: %[[IDX_CAST:.+]] = builtin.unrealized_conversion_cast %[[IDX]]78 // CHECK: %[[ZERO:.*]] = spirv.Constant 0 : i3279 // CHECK: %[[ADDR:.+]] = spirv.AccessChain %[[SRC_CAST]][%[[ZERO]], %[[IDX_CAST]]]80 // CHECK: %[[VAL:.+]] = spirv.Load "StorageBuffer" %[[ADDR]] : i881 // CHECK: %[[ZERO_I8:.+]] = spirv.Constant 0 : i882 // CHECK: %[[BOOL:.+]] = spirv.INotEqual %[[VAL]], %[[ZERO_I8]] : i883 %0 = memref.load %src[%i] : memref<4xi1, #spirv.storage_class<StorageBuffer>>84 // CHECK: return %[[BOOL]]85 return %0: i186}87 88// CHECK-LABEL: func @load_aligned89// CHECK-SAME: (%[[SRC:.+]]: memref<4xi1, #spirv.storage_class<StorageBuffer>>, %[[IDX:.+]]: index)90func.func @load_aligned(%src: memref<4xi1, #spirv.storage_class<StorageBuffer>>, %i : index) -> i1 {91 // CHECK: spirv.Load "StorageBuffer" {{.*}} ["Aligned", 32] : i892 %0 = memref.load %src[%i] { alignment = 32 } : memref<4xi1, #spirv.storage_class<StorageBuffer>>93 return %0: i194}95 96// CHECK-LABEL: func @load_aligned_nontemporal97func.func @load_aligned_nontemporal(%src: memref<4xi1, #spirv.storage_class<StorageBuffer>>, %i : index) -> i1 {98 // CHECK: spirv.Load "StorageBuffer" {{.*}} ["Aligned|Nontemporal", 32] : i899 %0 = memref.load %src[%i] { alignment = 32, nontemporal = true } : memref<4xi1, #spirv.storage_class<StorageBuffer>>100 return %0: i1101}102 103// CHECK-LABEL: func @load_aligned_psb104func.func @load_aligned_psb(%src: memref<4xi1, #spirv.storage_class<PhysicalStorageBuffer>>, %i : index) -> i1 {105 // CHECK: %[[VAL:.+]] = spirv.Load "PhysicalStorageBuffer" {{.*}} ["Aligned", 32] : i8106 %0 = memref.load %src[%i] { alignment = 32 } : memref<4xi1, #spirv.storage_class<PhysicalStorageBuffer>>107 return %0: i1108}109 110// CHECK-LABEL: func @store_i1111// CHECK-SAME: %[[DST:.+]]: memref<4xi1, #spirv.storage_class<StorageBuffer>>,112// CHECK-SAME: %[[IDX:.+]]: index113func.func @store_i1(%dst: memref<4xi1, #spirv.storage_class<StorageBuffer>>, %i: index) {114 %true = arith.constant true115 // CHECK-DAG: %[[DST_CAST:.+]] = builtin.unrealized_conversion_cast %[[DST]] : memref<4xi1, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<4 x i8, stride=1> [0])>, StorageBuffer>116 // CHECK-DAG: %[[IDX_CAST:.+]] = builtin.unrealized_conversion_cast %[[IDX]]117 // CHECK: %[[ZERO:.*]] = spirv.Constant 0 : i32118 // CHECK: %[[ADDR:.+]] = spirv.AccessChain %[[DST_CAST]][%[[ZERO]], %[[IDX_CAST]]]119 // CHECK: %[[ONE_I8:.+]] = spirv.Constant 1 : i8120 // CHECK: spirv.Store "StorageBuffer" %[[ADDR]], %[[ONE_I8]] : i8121 memref.store %true, %dst[%i]: memref<4xi1, #spirv.storage_class<StorageBuffer>>122 return123}124 125// CHECK-LABEL: @load_i16126func.func @load_i16(%arg0: memref<i16, #spirv.storage_class<StorageBuffer>>) {127 // CHECK-NOT: spirv.SDiv128 // CHECK: spirv.Load129 // CHECK-NOT: spirv.ShiftRightArithmetic130 %0 = memref.load %arg0[] : memref<i16, #spirv.storage_class<StorageBuffer>>131 return132}133 134// CHECK-LABEL: @store_i16135func.func @store_i16(%arg0: memref<10xi16, #spirv.storage_class<StorageBuffer>>, %index: index, %value: i16) {136 // CHECK: spirv.Store137 // CHECK-NOT: spirv.AtomicAnd138 // CHECK-NOT: spirv.AtomicOr139 memref.store %value, %arg0[%index] : memref<10xi16, #spirv.storage_class<StorageBuffer>>140 return141}142 143// CHECK-LABEL: @load_store_i32_physical144func.func @load_store_i32_physical(%arg0: memref<i32, #spirv.storage_class<PhysicalStorageBuffer>>) {145 // CHECK: spirv.Load "PhysicalStorageBuffer" %{{.+}} ["Aligned", 4] : i32146 // CHECK: spirv.Store "PhysicalStorageBuffer" %{{.+}}, %{{.+}} ["Aligned", 4] : i32147 %0 = memref.load %arg0[] : memref<i32, #spirv.storage_class<PhysicalStorageBuffer>>148 memref.store %0, %arg0[] : memref<i32, #spirv.storage_class<PhysicalStorageBuffer>>149 return150}151 152// CHECK-LABEL: @load_store_i8_physical153func.func @load_store_i8_physical(%arg0: memref<i8, #spirv.storage_class<PhysicalStorageBuffer>>) {154 // CHECK: spirv.Load "PhysicalStorageBuffer" %{{.+}} ["Aligned", 1] : i8155 // CHECK: spirv.Store "PhysicalStorageBuffer" %{{.+}}, %{{.+}} ["Aligned", 1] : i8156 %0 = memref.load %arg0[] : memref<i8, #spirv.storage_class<PhysicalStorageBuffer>>157 memref.store %0, %arg0[] : memref<i8, #spirv.storage_class<PhysicalStorageBuffer>>158 return159}160 161// CHECK-LABEL: @load_store_i1_physical162func.func @load_store_i1_physical(%arg0: memref<i1, #spirv.storage_class<PhysicalStorageBuffer>>) {163 // CHECK: spirv.Load "PhysicalStorageBuffer" %{{.+}} ["Aligned", 1] : i8164 // CHECK: spirv.Store "PhysicalStorageBuffer" %{{.+}}, %{{.+}} ["Aligned", 1] : i8165 %0 = memref.load %arg0[] : memref<i1, #spirv.storage_class<PhysicalStorageBuffer>>166 memref.store %0, %arg0[] : memref<i1, #spirv.storage_class<PhysicalStorageBuffer>>167 return168}169 170// CHECK-LABEL: @load_store_f32_physical171func.func @load_store_f32_physical(%arg0: memref<f32, #spirv.storage_class<PhysicalStorageBuffer>>) {172 // CHECK: spirv.Load "PhysicalStorageBuffer" %{{.+}} ["Aligned", 4] : f32173 // CHECK: spirv.Store "PhysicalStorageBuffer" %{{.+}}, %{{.+}} ["Aligned", 4] : f32174 %0 = memref.load %arg0[] : memref<f32, #spirv.storage_class<PhysicalStorageBuffer>>175 memref.store %0, %arg0[] : memref<f32, #spirv.storage_class<PhysicalStorageBuffer>>176 return177}178 179// CHECK-LABEL: @load_store_f16_physical180func.func @load_store_f16_physical(%arg0: memref<f16, #spirv.storage_class<PhysicalStorageBuffer>>) {181 // CHECK: spirv.Load "PhysicalStorageBuffer" %{{.+}} ["Aligned", 2] : f16182 // CHECK: spirv.Store "PhysicalStorageBuffer" %{{.+}}, %{{.+}} ["Aligned", 2] : f16183 %0 = memref.load %arg0[] : memref<f16, #spirv.storage_class<PhysicalStorageBuffer>>184 memref.store %0, %arg0[] : memref<f16, #spirv.storage_class<PhysicalStorageBuffer>>185 return186}187 188} // end module189 190// -----191 192// Check for Kernel capability, that with proper compute and storage extensions, we don't need to193// perform special tricks.194 195module attributes {196 spirv.target_env = #spirv.target_env<197 #spirv.vce<v1.0,198 [199 Kernel, Addresses, Int8, Int16, Int64, Float16, Float64], []>, #spirv.resource_limits<>>200} {201 202// CHECK-LABEL: @load_store_zero_rank_float203// CHECK-SAME: %[[OARG0:.*]]: memref{{.*}}, %[[OARG1:.*]]: memref204func.func @load_store_zero_rank_float(%arg0: memref<f32, #spirv.storage_class<CrossWorkgroup>>, %arg1: memref<f32, #spirv.storage_class<CrossWorkgroup>>) {205 // CHECK-DAG: [[ARG0:%.*]] = builtin.unrealized_conversion_cast %[[OARG0]] : memref<f32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<!spirv.array<1 x f32>, CrossWorkgroup>206 // CHECK-DAG: [[ARG1:%.*]] = builtin.unrealized_conversion_cast %[[OARG1]] : memref<f32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<!spirv.array<1 x f32>, CrossWorkgroup>207 // CHECK: [[ZERO:%.*]] = spirv.Constant 0 : i32208 // CHECK: spirv.AccessChain [[ARG0]][209 // CHECK-SAME: [[ZERO]]210 // CHECK-SAME: ] :211 // CHECK: spirv.Load "CrossWorkgroup" %{{.*}} : f32212 %0 = memref.load %arg0[] : memref<f32, #spirv.storage_class<CrossWorkgroup>>213 // CHECK: spirv.AccessChain [[ARG1]][214 // CHECK-SAME: [[ZERO]]215 // CHECK-SAME: ] :216 // CHECK: spirv.Store "CrossWorkgroup" %{{.*}} : f32217 memref.store %0, %arg1[] : memref<f32, #spirv.storage_class<CrossWorkgroup>>218 return219}220 221// CHECK-LABEL: @load_store_zero_rank_int222// CHECK-SAME: %[[OARG0:.*]]: memref{{.*}}, %[[OARG1:.*]]: memref223func.func @load_store_zero_rank_int(%arg0: memref<i32, #spirv.storage_class<CrossWorkgroup>>, %arg1: memref<i32, #spirv.storage_class<CrossWorkgroup>>) {224 // CHECK-DAG: [[ARG0:%.*]] = builtin.unrealized_conversion_cast %[[OARG0]] : memref<i32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<!spirv.array<1 x i32>, CrossWorkgroup>225 // CHECK-DAG: [[ARG1:%.*]] = builtin.unrealized_conversion_cast %[[OARG1]] : memref<i32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<!spirv.array<1 x i32>, CrossWorkgroup>226 // CHECK: [[ZERO:%.*]] = spirv.Constant 0 : i32227 // CHECK: spirv.AccessChain [[ARG0]][228 // CHECK-SAME: [[ZERO]]229 // CHECK-SAME: ] :230 // CHECK: spirv.Load "CrossWorkgroup" %{{.*}} : i32231 %0 = memref.load %arg0[] : memref<i32, #spirv.storage_class<CrossWorkgroup>>232 // CHECK: spirv.AccessChain [[ARG1]][233 // CHECK-SAME: [[ZERO]]234 // CHECK-SAME: ] :235 // CHECK: spirv.Store "CrossWorkgroup" %{{.*}} : i32236 memref.store %0, %arg1[] : memref<i32, #spirv.storage_class<CrossWorkgroup>>237 return238}239 240// CHECK-LABEL: func @load_store_unknown_dim241// CHECK-SAME: %[[OARG0:.*]]: index, %[[OARG1:.*]]: memref{{.*}}, %[[OARG2:.*]]: memref242func.func @load_store_unknown_dim(%i: index, %source: memref<?xi32, #spirv.storage_class<CrossWorkgroup>>, %dest: memref<?xi32, #spirv.storage_class<CrossWorkgroup>>) {243 // CHECK-DAG: %[[SRC:.+]] = builtin.unrealized_conversion_cast %[[OARG1]] : memref<?xi32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<i32, CrossWorkgroup>244 // CHECK-DAG: %[[DST:.+]] = builtin.unrealized_conversion_cast %[[OARG2]] : memref<?xi32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<i32, CrossWorkgroup>245 // CHECK: %[[AC0:.+]] = spirv.PtrAccessChain %[[SRC]]246 // CHECK: spirv.Load "CrossWorkgroup" %[[AC0]]247 %0 = memref.load %source[%i] : memref<?xi32, #spirv.storage_class<CrossWorkgroup>>248 // CHECK: %[[AC1:.+]] = spirv.PtrAccessChain %[[DST]]249 // CHECK: spirv.Store "CrossWorkgroup" %[[AC1]]250 memref.store %0, %dest[%i]: memref<?xi32, #spirv.storage_class<CrossWorkgroup>>251 return252}253 254// CHECK-LABEL: func @load_i1255// CHECK-SAME: (%[[SRC:.+]]: memref<4xi1, #spirv.storage_class<CrossWorkgroup>>, %[[IDX:.+]]: index)256func.func @load_i1(%src: memref<4xi1, #spirv.storage_class<CrossWorkgroup>>, %i : index) -> i1 {257 // CHECK-DAG: %[[SRC_CAST:.+]] = builtin.unrealized_conversion_cast %[[SRC]] : memref<4xi1, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<!spirv.array<4 x i8>, CrossWorkgroup>258 // CHECK-DAG: %[[IDX_CAST:.+]] = builtin.unrealized_conversion_cast %[[IDX]]259 // CHECK: %[[ADDR:.+]] = spirv.AccessChain %[[SRC_CAST]][%[[IDX_CAST]]]260 // CHECK: %[[VAL:.+]] = spirv.Load "CrossWorkgroup" %[[ADDR]] : i8261 // CHECK: %[[ZERO_I8:.+]] = spirv.Constant 0 : i8262 // CHECK: %[[BOOL:.+]] = spirv.INotEqual %[[VAL]], %[[ZERO_I8]] : i8263 %0 = memref.load %src[%i] : memref<4xi1, #spirv.storage_class<CrossWorkgroup>>264 // CHECK: return %[[BOOL]]265 return %0: i1266}267 268// CHECK-LABEL: func @store_i1269// CHECK-SAME: %[[DST:.+]]: memref<4xi1, #spirv.storage_class<CrossWorkgroup>>,270// CHECK-SAME: %[[IDX:.+]]: index271func.func @store_i1(%dst: memref<4xi1, #spirv.storage_class<CrossWorkgroup>>, %i: index) {272 %true = arith.constant true273 // CHECK-DAG: %[[DST_CAST:.+]] = builtin.unrealized_conversion_cast %[[DST]] : memref<4xi1, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<!spirv.array<4 x i8>, CrossWorkgroup>274 // CHECK-DAG: %[[IDX_CAST:.+]] = builtin.unrealized_conversion_cast %[[IDX]]275 // CHECK: %[[ADDR:.+]] = spirv.AccessChain %[[DST_CAST]][%[[IDX_CAST]]]276 // CHECK: %[[ONE_I8:.+]] = spirv.Constant 1 : i8277 // CHECK: spirv.Store "CrossWorkgroup" %[[ADDR]], %[[ONE_I8]] : i8278 memref.store %true, %dst[%i]: memref<4xi1, #spirv.storage_class<CrossWorkgroup>>279 return280}281 282} // end module283 284// -----285 286// Check address space casts287 288module attributes {289 spirv.target_env = #spirv.target_env<290 #spirv.vce<v1.0,291 [292 Kernel, Addresses, GenericPointer], []>, #spirv.resource_limits<>>293} {294 295// CHECK-LABEL: func.func @memory_space_cast296func.func @memory_space_cast(%arg: memref<4xf32, #spirv.storage_class<CrossWorkgroup>>)297 -> memref<4xf32, #spirv.storage_class<Function>> {298 // CHECK: %[[ARG_CAST:.+]] = builtin.unrealized_conversion_cast {{.*}} to !spirv.ptr<!spirv.array<4 x f32>, CrossWorkgroup>299 // CHECK: %[[TO_GENERIC:.+]] = spirv.PtrCastToGeneric %[[ARG_CAST]] : !spirv.ptr<!spirv.array<4 x f32>, CrossWorkgroup> to !spirv.ptr<!spirv.array<4 x f32>, Generic>300 // CHECK: %[[TO_PRIVATE:.+]] = spirv.GenericCastToPtr %[[TO_GENERIC]] : !spirv.ptr<!spirv.array<4 x f32>, Generic> to !spirv.ptr<!spirv.array<4 x f32>, Function>301 // CHECK: %[[RET:.+]] = builtin.unrealized_conversion_cast %[[TO_PRIVATE]]302 // CHECK: return %[[RET]]303 %ret = memref.memory_space_cast %arg : memref<4xf32, #spirv.storage_class<CrossWorkgroup>>304 to memref<4xf32, #spirv.storage_class<Function>>305 return %ret : memref<4xf32, #spirv.storage_class<Function>>306}307 308} // end module309 310// -----311 312// Check that casts are properly inserted if the corresponding **compute**313// capability is allowed.314module attributes {315 spirv.target_env = #spirv.target_env<316 #spirv.vce<v1.0, [Shader, Int8, Int16], [317 SPV_KHR_8bit_storage, SPV_KHR_16bit_storage, SPV_KHR_storage_buffer_storage_class318 ]>, #spirv.resource_limits<>>319} {320 321// CHECK-LABEL: @load_i1322func.func @load_i1(%arg0: memref<i1, #spirv.storage_class<StorageBuffer>>) -> i1 {323 // CHECK: %[[ONE:.+]] = spirv.Constant 1 : i32324 // CHECK: %[[RES:.+]] = spirv.IEqual %{{.+}}, %[[ONE]] : i32325 // CHECK: return %[[RES]]326 %0 = memref.load %arg0[] : memref<i1, #spirv.storage_class<StorageBuffer>>327 return %0 : i1328}329 330// CHECK-LABEL: @load_i8331func.func @load_i8(%arg0: memref<i8, #spirv.storage_class<StorageBuffer>>) -> i8 {332 // CHECK: %[[RES:.+]] = spirv.UConvert %{{.+}} : i32 to i8333 // CHECK: return %[[RES]]334 %0 = memref.load %arg0[] : memref<i8, #spirv.storage_class<StorageBuffer>>335 return %0 : i8336}337 338// CHECK-LABEL: @load_i16339func.func @load_i16(%arg0: memref<10xi16, #spirv.storage_class<StorageBuffer>>, %index : index) -> i16 {340 // CHECK: %[[RES:.+]] = spirv.UConvert %{{.+}} : i32 to i16341 // CHECK: return %[[RES]]342 %0 = memref.load %arg0[%index] : memref<10xi16, #spirv.storage_class<StorageBuffer>>343 return %0: i16344}345 346} // end module347 348// -----349 350// Check reinterpret_casts351 352module attributes {353 spirv.target_env = #spirv.target_env<354 #spirv.vce<v1.0,355 [Kernel, Addresses, GenericPointer], []>, #spirv.resource_limits<>>356} {357 358// CHECK-LABEL: func.func @reinterpret_cast359// CHECK-SAME: (%[[MEM:.*]]: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>, %[[OFF:.*]]: index)360func.func @reinterpret_cast(%arg: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>, %arg1: index) -> memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>> {361// CHECK-DAG: %[[MEM1:.*]] = builtin.unrealized_conversion_cast %[[MEM]] : memref<?xf32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<f32, CrossWorkgroup>362// CHECK-DAG: %[[OFF1:.*]] = builtin.unrealized_conversion_cast %[[OFF]] : index to i32363// CHECK: %[[RET:.*]] = spirv.InBoundsPtrAccessChain %[[MEM1]][%[[OFF1]]] : !spirv.ptr<f32, CrossWorkgroup>, i32364// CHECK: %[[RET1:.*]] = builtin.unrealized_conversion_cast %[[RET]] : !spirv.ptr<f32, CrossWorkgroup> to memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>365// CHECK: return %[[RET1]]366 %ret = memref.reinterpret_cast %arg to offset: [%arg1], sizes: [10], strides: [1] : memref<?xf32, #spirv.storage_class<CrossWorkgroup>> to memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>367 return %ret : memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>368}369 370// CHECK-LABEL: func.func @reinterpret_cast_0371// CHECK-SAME: (%[[MEM:.*]]: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>)372func.func @reinterpret_cast_0(%arg: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>) -> memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>> {373// CHECK-DAG: %[[MEM1:.*]] = builtin.unrealized_conversion_cast %[[MEM]] : memref<?xf32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<f32, CrossWorkgroup>374// CHECK-DAG: %[[RET:.*]] = builtin.unrealized_conversion_cast %[[MEM1]] : !spirv.ptr<f32, CrossWorkgroup> to memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>375// CHECK: return %[[RET]]376 %ret = memref.reinterpret_cast %arg to offset: [0], sizes: [10], strides: [1] : memref<?xf32, #spirv.storage_class<CrossWorkgroup>> to memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>377 return %ret : memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>378}379 380// CHECK-LABEL: func.func @reinterpret_cast_5381// CHECK-SAME: (%[[MEM:.*]]: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>)382func.func @reinterpret_cast_5(%arg: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>) -> memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>> {383// CHECK: %[[MEM1:.*]] = builtin.unrealized_conversion_cast %[[MEM]] : memref<?xf32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<f32, CrossWorkgroup>384// CHECK: %[[OFF:.*]] = spirv.Constant 5 : i32385// CHECK: %[[RET:.*]] = spirv.InBoundsPtrAccessChain %[[MEM1]][%[[OFF]]] : !spirv.ptr<f32, CrossWorkgroup>, i32386// CHECK: %[[RET1:.*]] = builtin.unrealized_conversion_cast %[[RET]] : !spirv.ptr<f32, CrossWorkgroup> to memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>387// CHECK: return %[[RET1]]388 %ret = memref.reinterpret_cast %arg to offset: [5], sizes: [10], strides: [1] : memref<?xf32, #spirv.storage_class<CrossWorkgroup>> to memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>389 return %ret : memref<?xf32, strided<[1], offset: ?>, #spirv.storage_class<CrossWorkgroup>>390}391 392} // end module393 394 395// -----396 397// Check casts398 399module attributes {400 spirv.target_env = #spirv.target_env<401 #spirv.vce<v1.0,402 [Kernel, Addresses, GenericPointer], []>, #spirv.resource_limits<>>403} {404 405// CHECK-LABEL: func.func @cast406// CHECK-SAME: (%[[MEM:.*]]: memref<4x?xf32, #spirv.storage_class<CrossWorkgroup>>)407func.func @cast(%arg: memref<4x?xf32, #spirv.storage_class<CrossWorkgroup>>) -> memref<?x4xf32, #spirv.storage_class<CrossWorkgroup>> {408// CHECK-DAG: %[[MEM1:.*]] = builtin.unrealized_conversion_cast %[[MEM]] : memref<4x?xf32, #spirv.storage_class<CrossWorkgroup>> to !spirv.ptr<f32, CrossWorkgroup>409// CHECK-DAG: %[[MEM2:.*]] = builtin.unrealized_conversion_cast %[[MEM1]] : !spirv.ptr<f32, CrossWorkgroup> to memref<?x4xf32, #spirv.storage_class<CrossWorkgroup>>410// CHECK: return %[[MEM2]]411 %ret = memref.cast %arg : memref<4x?xf32, #spirv.storage_class<CrossWorkgroup>> to memref<?x4xf32, #spirv.storage_class<CrossWorkgroup>>412 return %ret : memref<?x4xf32, #spirv.storage_class<CrossWorkgroup>>413}414 415// TODO: Not supported yet416// CHECK-LABEL: func.func @cast_from_static417// CHECK-SAME: (%[[MEM:.*]]: memref<4x4xf32, #spirv.storage_class<CrossWorkgroup>>)418func.func @cast_from_static(%arg: memref<4x4xf32, #spirv.storage_class<CrossWorkgroup>>) -> memref<?x4xf32, #spirv.storage_class<CrossWorkgroup>> {419// CHECK: %[[MEM1:.*]] = memref.cast %[[MEM]] : memref<4x4xf32, #spirv.storage_class<CrossWorkgroup>> to memref<?x4xf32, #spirv.storage_class<CrossWorkgroup>>420// CHECK: return %[[MEM1]]421 %ret = memref.cast %arg : memref<4x4xf32, #spirv.storage_class<CrossWorkgroup>> to memref<?x4xf32, #spirv.storage_class<CrossWorkgroup>>422 return %ret : memref<?x4xf32, #spirv.storage_class<CrossWorkgroup>>423}424 425// TODO: Not supported yet426// CHECK-LABEL: func.func @cast_to_static427// CHECK-SAME: (%[[MEM:.*]]: memref<4x?xf32, #spirv.storage_class<CrossWorkgroup>>)428func.func @cast_to_static(%arg: memref<4x?xf32, #spirv.storage_class<CrossWorkgroup>>) -> memref<4x4xf32, #spirv.storage_class<CrossWorkgroup>> {429// CHECK: %[[MEM1:.*]] = memref.cast %[[MEM]] : memref<4x?xf32, #spirv.storage_class<CrossWorkgroup>> to memref<4x4xf32, #spirv.storage_class<CrossWorkgroup>>430// CHECK: return %[[MEM1]]431 %ret = memref.cast %arg : memref<4x?xf32, #spirv.storage_class<CrossWorkgroup>> to memref<4x4xf32, #spirv.storage_class<CrossWorkgroup>>432 return %ret : memref<4x4xf32, #spirv.storage_class<CrossWorkgroup>>433}434 435// TODO: Not supported yet436// CHECK-LABEL: func.func @cast_to_static_zero_elems437// CHECK-SAME: (%[[MEM:.*]]: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>)438func.func @cast_to_static_zero_elems(%arg: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>) -> memref<0xf32, #spirv.storage_class<CrossWorkgroup>> {439// CHECK: %[[MEM1:.*]] = memref.cast %[[MEM]] : memref<?xf32, #spirv.storage_class<CrossWorkgroup>> to memref<0xf32, #spirv.storage_class<CrossWorkgroup>>440// CHECK: return %[[MEM1]]441 %ret = memref.cast %arg : memref<?xf32, #spirv.storage_class<CrossWorkgroup>> to memref<0xf32, #spirv.storage_class<CrossWorkgroup>>442 return %ret : memref<0xf32, #spirv.storage_class<CrossWorkgroup>>443}444 445}446 447// -----448 449module attributes {450 spirv.target_env = #spirv.target_env<#spirv.vce<v1.5, [Kernel, Int64, Addresses, PhysicalStorageBufferAddresses], []>, #spirv.resource_limits<>>451} {452// CHECK-LABEL: func @extract_aligned_pointer_as_index_kernel453func.func @extract_aligned_pointer_as_index_kernel(%m: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>) -> index {454 %0 = memref.extract_aligned_pointer_as_index %m: memref<?xf32, #spirv.storage_class<CrossWorkgroup>> -> index455 // CHECK: %[[I32:.*]] = spirv.ConvertPtrToU {{%.*}} : !spirv.ptr<f32, CrossWorkgroup> to i32456 // CHECK: %[[R:.*]] = builtin.unrealized_conversion_cast %[[I32]] : i32 to index457 // CHECK64: %[[I64:.*]] = spirv.ConvertPtrToU {{%.*}} : !spirv.ptr<f32, CrossWorkgroup> to i64458 // CHECK64: %[[R:.*]] = builtin.unrealized_conversion_cast %[[I64]] : i64 to index459 460 // CHECK: return %[[R:.*]] : index461 return %0: index462}463}464 465// -----466 467module attributes {468 spirv.target_env = #spirv.target_env<#spirv.vce<v1.5, [Shader, Int64, Addresses, PhysicalStorageBufferAddresses], []>, #spirv.resource_limits<>>469} {470// CHECK-LABEL: func @extract_aligned_pointer_as_index_shader471func.func @extract_aligned_pointer_as_index_shader(%m: memref<?xf32, #spirv.storage_class<CrossWorkgroup>>) -> index {472 %0 = memref.extract_aligned_pointer_as_index %m: memref<?xf32, #spirv.storage_class<CrossWorkgroup>> -> index473 // CHECK: %[[I32:.*]] = spirv.ConvertPtrToU {{%.*}} : !spirv.ptr<!spirv.struct<(!spirv.rtarray<f32>)>, CrossWorkgroup> to i32474 // CHECK: %[[R:.*]] = builtin.unrealized_conversion_cast %[[I32]] : i32 to index475 // CHECK64: %[[I64:.*]] = spirv.ConvertPtrToU {{%.*}} : !spirv.ptr<!spirv.struct<(!spirv.rtarray<f32>)>, CrossWorkgroup> to i64476 // CHECK64: %[[R:.*]] = builtin.unrealized_conversion_cast %[[I64]] : i64 to index477 478 // CHECK: return %[[R:.*]] : index479 return %0: index480}481}482 483 484// -----485 486// Check nontemporal attribute487 488module attributes {489 spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [490 Shader,491 PhysicalStorageBufferAddresses492 ], [493 SPV_KHR_storage_buffer_storage_class,494 SPV_KHR_physical_storage_buffer495 ]>, #spirv.resource_limits<>>496} {497 func.func @load_nontemporal(%arg0: memref<f32, #spirv.storage_class<StorageBuffer>>) {498 %0 = memref.load %arg0[] {nontemporal = true} : memref<f32, #spirv.storage_class<StorageBuffer>>499// CHECK: spirv.Load "StorageBuffer" %{{.+}} ["Nontemporal"] : f32500 memref.store %0, %arg0[] {nontemporal = true} : memref<f32, #spirv.storage_class<StorageBuffer>>501// CHECK: spirv.Store "StorageBuffer" %{{.+}}, %{{.+}} ["Nontemporal"] : f32502 return503 }504 505 func.func @load_nontemporal_aligned(%arg0: memref<f32, #spirv.storage_class<PhysicalStorageBuffer>>) {506 %0 = memref.load %arg0[] {nontemporal = true} : memref<f32, #spirv.storage_class<PhysicalStorageBuffer>>507// CHECK: spirv.Load "PhysicalStorageBuffer" %{{.+}} ["Aligned|Nontemporal", 4] : f32508 memref.store %0, %arg0[] {nontemporal = true} : memref<f32, #spirv.storage_class<PhysicalStorageBuffer>>509// CHECK: spirv.Store "PhysicalStorageBuffer" %{{.+}}, %{{.+}} ["Aligned|Nontemporal", 4] : f32510 return511 }512}513 514// -----515 516// Check Image Support.517 518// CHECK: #[[$COLMAJMAP:.*]] = affine_map<(d0, d1) -> (d1, d0)>519#col_major = affine_map<(d0, d1) -> (d1, d0)>520// CHECK: #[[$CUSTOMLAYOUTMAP:.*]] = affine_map<(d0, d1, d2) -> (d2, d1, d0)>521#custom = affine_map<(d0, d1, d2) -> (d2, d1, d0)>522// CHECK: #[[$NONPERMMAP:.*]] = affine_map<(d0, d1) -> (d0, d1 mod 2)>523#non_permutation = affine_map<(d0, d1) -> (d0, d1 mod 2)>524module attributes {525 spirv.target_env = #spirv.target_env<#spirv.vce<v1.0, [526 Shader,527 PhysicalStorageBufferAddresses,528 Image1D,529 StorageImageExtendedFormats,530 Float16,531 StorageBuffer16BitAccess,532 StorageUniform16,533 Int16534 ], [535 SPV_KHR_storage_buffer_storage_class,536 SPV_KHR_physical_storage_buffer,537 SPV_KHR_16bit_storage538 ]>, #spirv.resource_limits<>>539} {540 // CHECK-LABEL: @load_from_image_1D(541 // CHECK-SAME: %[[ARG0:.*]]: memref<1xf32, #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<1xf32, #spirv.storage_class<StorageBuffer>>542 func.func @load_from_image_1D(%arg0: memref<1xf32, #spirv.storage_class<Image>>, %arg1: memref<1xf32, #spirv.storage_class<StorageBuffer>>) {543// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<1xf32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<1 x f32, stride=4> [0])>, StorageBuffer>544// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<1xf32, #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<f32, Dim1D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>, UniformConstant>545 %cst = arith.constant 0 : index546 // CHECK: %[[COORDS:.*]] = builtin.unrealized_conversion_cast %{{.*}} : index to i32547 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<f32, Dim1D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>548 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<f32, Dim1D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>549 // CHECK-NOT: spirv.CompositeConstruct550 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<f32, Dim1D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>, i32 -> vector<4xf32>551 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xf32>552 %0 = memref.load %arg0[%cst] : memref<1xf32, #spirv.storage_class<Image>>553 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : f32554 memref.store %0, %arg1[%cst] : memref<1xf32, #spirv.storage_class<StorageBuffer>>555 return556 }557 558 // CHECK-LABEL: @load_from_image_2D(559 // CHECK-SAME: %[[ARG0:.*]]: memref<2x4xf32, #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x4xf32, #spirv.storage_class<StorageBuffer>>560 func.func @load_from_image_2D(%arg0: memref<2x4xf32, #spirv.storage_class<Image>>, %arg1: memref<2x4xf32, #spirv.storage_class<StorageBuffer>>) {561// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x4xf32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<8 x f32, stride=4> [0])>, StorageBuffer>562// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x4xf32, #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<f32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>, UniformConstant>563 // CHECK: %[[X:.*]] = arith.constant 3 : index564 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32565 %x = arith.constant 3 : index566 // CHECK: %[[Y:.*]] = arith.constant 1 : index567 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32568 %y = arith.constant 1 : index569 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<f32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>570 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<f32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>571 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]] : (i32, i32) -> vector<2xi32>572 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<f32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>, vector<2xi32> -> vector<4xf32>573 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xf32>574 %0 = memref.load %arg0[%y, %x] : memref<2x4xf32, #spirv.storage_class<Image>>575 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : f32576 memref.store %0, %arg1[%y, %x] : memref<2x4xf32, #spirv.storage_class<StorageBuffer>>577 return578 }579 580 // CHECK-LABEL: @load_from_col_major_image_2D(581 // CHECK-SAME: %[[ARG0:.*]]: memref<2x4xf32, #[[$COLMAJMAP]], #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x4xf32, #spirv.storage_class<StorageBuffer>>582 func.func @load_from_col_major_image_2D(%arg0: memref<2x4xf32, #col_major, #spirv.storage_class<Image>>, %arg1: memref<2x4xf32, #spirv.storage_class<StorageBuffer>>) {583// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x4xf32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<8 x f32, stride=4> [0])>, StorageBuffer>584// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x4xf32, #[[$COLMAJMAP]], #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<f32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>, UniformConstant>585 // CHECK: %[[X:.*]] = arith.constant 3 : index586 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32587 %x = arith.constant 3 : index588 // CHECK: %[[Y:.*]] = arith.constant 1 : index589 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32590 %y = arith.constant 1 : index591 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<f32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>592 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<f32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>593 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]] : (i32, i32) -> vector<2xi32>594 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<f32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>, vector<2xi32> -> vector<4xf32>595 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xf32>596 %0 = memref.load %arg0[%x, %y] : memref<2x4xf32, #col_major, #spirv.storage_class<Image>>597 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : f32598 memref.store %0, %arg1[%y, %x] : memref<2x4xf32, #spirv.storage_class<StorageBuffer>>599 return600 }601 602 // CHECK-LABEL: @load_from_image_3D(603 // CHECK-SAME: %[[ARG0:.*]]: memref<2x3x4xf32, #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x3x4xf32, #spirv.storage_class<StorageBuffer>>604 func.func @load_from_image_3D(%arg0: memref<2x3x4xf32, #spirv.storage_class<Image>>, %arg1: memref<2x3x4xf32, #spirv.storage_class<StorageBuffer>>) {605// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x3x4xf32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<24 x f32, stride=4> [0])>, StorageBuffer>606// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x3x4xf32, #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<f32, Dim3D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>, UniformConstant>607 // CHECK: %[[X:.*]] = arith.constant 3 : index608 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32609 %x = arith.constant 3 : index610 // CHECK: %[[Y:.*]] = arith.constant 2 : index611 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32612 %y = arith.constant 2 : index613 // CHECK: %[[Z:.*]] = arith.constant 1 : index614 // CHECK: %[[Z32:.*]] = builtin.unrealized_conversion_cast %[[Z]] : index to i32615 %z = arith.constant 1 : index616 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<f32, Dim3D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>617 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<f32, Dim3D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>618 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]], %[[Z32]] : (i32, i32, i32) -> vector<3xi32>619 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<f32, Dim3D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>, vector<3xi32> -> vector<4xf32>620 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xf32>621 %0 = memref.load %arg0[%z, %y, %x] : memref<2x3x4xf32, #spirv.storage_class<Image>>622 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : f32623 memref.store %0, %arg1[%z, %y, %x] : memref<2x3x4xf32, #spirv.storage_class<StorageBuffer>>624 return625 }626 627 // CHECK-LABEL: @load_from_custom_layout_image_3D(628 // CHECK-SAME: %[[ARG0:.*]]: memref<2x3x4xf32, #[[$CUSTOMLAYOUTMAP]], #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x3x4xf32, #spirv.storage_class<StorageBuffer>>629 func.func @load_from_custom_layout_image_3D(%arg0: memref<2x3x4xf32, #custom, #spirv.storage_class<Image>>, %arg1: memref<2x3x4xf32, #spirv.storage_class<StorageBuffer>>) {630// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x3x4xf32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<24 x f32, stride=4> [0])>, StorageBuffer>631// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x3x4xf32, #[[$CUSTOMLAYOUTMAP]], #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<f32, Dim3D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>, UniformConstant>632 // CHECK: %[[X:.*]] = arith.constant 3 : index633 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32634 %x = arith.constant 3 : index635 // CHECK: %[[Y:.*]] = arith.constant 2 : index636 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32637 %y = arith.constant 2 : index638 // CHECK: %[[Z:.*]] = arith.constant 1 : index639 // CHECK: %[[Z32:.*]] = builtin.unrealized_conversion_cast %[[Z]] : index to i32640 %z = arith.constant 1 : index641 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<f32, Dim3D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>642 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<f32, Dim3D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>>643 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]], %[[Z32]] : (i32, i32, i32) -> vector<3xi32>644 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<f32, Dim3D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32f>, vector<3xi32> -> vector<4xf32>645 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xf32>646 %0 = memref.load %arg0[%x, %y, %z] : memref<2x3x4xf32, #custom, #spirv.storage_class<Image>>647 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : f32648 memref.store %0, %arg1[%z, %y, %x] : memref<2x3x4xf32, #spirv.storage_class<StorageBuffer>>649 return650 }651 652 // CHECK-LABEL: @load_from_image_2D_f16(653 // CHECK-SAME: %[[ARG0:.*]]: memref<2x3xf16, #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x3xf16, #spirv.storage_class<StorageBuffer>>654 func.func @load_from_image_2D_f16(%arg0: memref<2x3xf16, #spirv.storage_class<Image>>, %arg1: memref<2x3xf16, #spirv.storage_class<StorageBuffer>>) {655// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x3xf16, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<6 x f16, stride=2> [0])>, StorageBuffer>656// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x3xf16, #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<f16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16f>>, UniformConstant>657 // CHECK: %[[X:.*]] = arith.constant 2 : index658 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32659 %x = arith.constant 2 : index660 // CHECK: %[[Y:.*]] = arith.constant 1 : index661 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32662 %y = arith.constant 1 : index663 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<f16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16f>>664 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<f16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16f>>665 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]] : (i32, i32) -> vector<2xi32>666 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<f16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16f>, vector<2xi32> -> vector<4xf16>667 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xf16>668 %0 = memref.load %arg0[%y, %x] : memref<2x3xf16, #spirv.storage_class<Image>>669 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : f16670 memref.store %0, %arg1[%y, %x] : memref<2x3xf16, #spirv.storage_class<StorageBuffer>>671 return672 }673 674 // CHECK-LABEL: @load_from_image_2D_i32(675 // CHECK-SAME: %[[ARG0:.*]]: memref<2x3xi32, #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x3xi32, #spirv.storage_class<StorageBuffer>>676 func.func @load_from_image_2D_i32(%arg0: memref<2x3xi32, #spirv.storage_class<Image>>, %arg1: memref<2x3xi32, #spirv.storage_class<StorageBuffer>>) {677// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x3xi32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<6 x i32, stride=4> [0])>, StorageBuffer>678// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x3xi32, #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<i32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32i>>, UniformConstant>679 // CHECK: %[[X:.*]] = arith.constant 2 : index680 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32681 %x = arith.constant 2 : index682 // CHECK: %[[Y:.*]] = arith.constant 1 : index683 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32684 %y = arith.constant 1 : index685 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<i32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32i>>686 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<i32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32i>>687 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]] : (i32, i32) -> vector<2xi32>688 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<i32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32i>, vector<2xi32> -> vector<4xi32>689 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xi32>690 %0 = memref.load %arg0[%y, %x] : memref<2x3xi32, #spirv.storage_class<Image>>691 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : i32692 memref.store %0, %arg1[%y, %x] : memref<2x3xi32, #spirv.storage_class<StorageBuffer>>693 return694 }695 696 // CHECK-LABEL: @load_from_image_2D_ui32(697 // CHECK-SAME: %[[ARG0:.*]]: memref<2x3xui32, #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x3xui32, #spirv.storage_class<StorageBuffer>>698 func.func @load_from_image_2D_ui32(%arg0: memref<2x3xui32, #spirv.storage_class<Image>>, %arg1: memref<2x3xui32, #spirv.storage_class<StorageBuffer>>) {699// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x3xui32, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<6 x ui32, stride=4> [0])>, StorageBuffer>700// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x3xui32, #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<ui32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32ui>>, UniformConstant>701 // CHECK: %[[X:.*]] = arith.constant 2 : index702 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32703 %x = arith.constant 2 : index704 // CHECK: %[[Y:.*]] = arith.constant 1 : index705 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32706 %y = arith.constant 1 : index707 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<ui32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32ui>>708 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<ui32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32ui>>709 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]] : (i32, i32) -> vector<2xi32>710 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<ui32, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R32ui>, vector<2xi32> -> vector<4xui32>711 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xui32>712 %0 = memref.load %arg0[%y, %x] : memref<2x3xui32, #spirv.storage_class<Image>>713 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : ui32714 memref.store %0, %arg1[%y, %x] : memref<2x3xui32, #spirv.storage_class<StorageBuffer>>715 return716 }717 718 // CHECK-LABEL: @load_from_image_2D_i16(719 // CHECK-SAME: %[[ARG0:.*]]: memref<2x3xi16, #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x3xi16, #spirv.storage_class<StorageBuffer>>720 func.func @load_from_image_2D_i16(%arg0: memref<2x3xi16, #spirv.storage_class<Image>>, %arg1: memref<2x3xi16, #spirv.storage_class<StorageBuffer>>) {721// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x3xi16, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<6 x i16, stride=2> [0])>, StorageBuffer>722// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x3xi16, #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<i16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16i>>, UniformConstant>723 // CHECK: %[[X:.*]] = arith.constant 2 : index724 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32725 %x = arith.constant 2 : index726 // CHECK: %[[Y:.*]] = arith.constant 1 : index727 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32728 %y = arith.constant 1 : index729 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<i16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16i>>730 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<i16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16i>>731 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]] : (i32, i32) -> vector<2xi32>732 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<i16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16i>, vector<2xi32> -> vector<4xi16>733 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xi16>734 %0 = memref.load %arg0[%y, %x] : memref<2x3xi16, #spirv.storage_class<Image>>735 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : i16736 memref.store %0, %arg1[%y, %x] : memref<2x3xi16, #spirv.storage_class<StorageBuffer>>737 return738 }739 740 // CHECK-LABEL: @load_from_image_2D_ui16(741 // CHECK-SAME: %[[ARG0:.*]]: memref<2x3xui16, #spirv.storage_class<Image>>, %[[ARG1:.*]]: memref<2x3xui16, #spirv.storage_class<StorageBuffer>>742 func.func @load_from_image_2D_ui16(%arg0: memref<2x3xui16, #spirv.storage_class<Image>>, %arg1: memref<2x3xui16, #spirv.storage_class<StorageBuffer>>) {743// CHECK-DAG: %[[SB:.*]] = builtin.unrealized_conversion_cast %[[ARG1]] : memref<2x3xui16, #spirv.storage_class<StorageBuffer>> to !spirv.ptr<!spirv.struct<(!spirv.array<6 x ui16, stride=2> [0])>, StorageBuffer>744// CHECK-DAG: %[[IMAGE_PTR:.*]] = builtin.unrealized_conversion_cast %[[ARG0]] : memref<2x3xui16, #spirv.storage_class<Image>> to !spirv.ptr<!spirv.sampled_image<!spirv.image<ui16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16ui>>, UniformConstant>745 // CHECK: %[[X:.*]] = arith.constant 2 : index746 // CHECK: %[[X32:.*]] = builtin.unrealized_conversion_cast %[[X]] : index to i32747 %x = arith.constant 2 : index748 // CHECK: %[[Y:.*]] = arith.constant 1 : index749 // CHECK: %[[Y32:.*]] = builtin.unrealized_conversion_cast %[[Y]] : index to i32750 %y = arith.constant 1 : index751 // CHECK: %[[SIMAGE:.*]] = spirv.Load "UniformConstant" %[[IMAGE_PTR]] : !spirv.sampled_image<!spirv.image<ui16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16ui>>752 // CHECK: %[[IMAGE:.*]] = spirv.Image %[[SIMAGE]] : !spirv.sampled_image<!spirv.image<ui16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16ui>>753 // CHECK: %[[COORDS:.*]] = spirv.CompositeConstruct %[[X32]], %[[Y32]] : (i32, i32) -> vector<2xi32>754 // CHECK: %[[RES_VEC:.*]] = spirv.ImageFetch %[[IMAGE]], %[[COORDS]] : !spirv.image<ui16, Dim2D, DepthUnknown, NonArrayed, SingleSampled, NeedSampler, R16ui>, vector<2xi32> -> vector<4xui16>755 // CHECK: %[[RESULT:.*]] = spirv.CompositeExtract %[[RES_VEC]][0 : i32] : vector<4xui16>756 %0 = memref.load %arg0[%y, %x] : memref<2x3xui16, #spirv.storage_class<Image>>757 // CHECK: spirv.Store "StorageBuffer" %{{.*}}, %[[RESULT]] : ui16758 memref.store %0, %arg1[%y, %x] : memref<2x3xui16, #spirv.storage_class<StorageBuffer>>759 return760 }761 762 // CHECK-LABEL: @load_from_image_2D_rank0(763 func.func @load_from_image_2D_rank0(%arg0: memref<f32, #spirv.storage_class<Image>>, %arg1: memref<f32, #spirv.storage_class<StorageBuffer>>) {764 %cst = arith.constant 0 : index765 // CHECK-NOT: spirv.Image766 // CHECK-NOT: spirv.ImageFetch767 %0 = memref.load %arg0[] : memref<f32, #spirv.storage_class<Image>>768 memref.store %0, %arg1[] : memref<f32, #spirv.storage_class<StorageBuffer>>769 return770 }771 772 // CHECK-LABEL: @load_from_image_2D_rank4(773 func.func @load_from_image_2D_rank4(%arg0: memref<1x1x1x1xf32, #spirv.storage_class<Image>>, %arg1: memref<1x1x1x1xf32, #spirv.storage_class<StorageBuffer>>) {774 %cst = arith.constant 0 : index775 // CHECK-NOT: spirv.Image776 // CHECK-NOT: spirv.ImageFetch777 %0 = memref.load %arg0[%cst, %cst, %cst, %cst] : memref<1x1x1x1xf32, #spirv.storage_class<Image>>778 memref.store %0, %arg1[%cst, %cst, %cst, %cst] : memref<1x1x1x1xf32, #spirv.storage_class<StorageBuffer>>779 return780 }781 782 // CHECK-LABEL: @load_from_image_2D_vector(783 func.func @load_from_image_2D_vector(%arg0: memref<1xvector<1xf32>, #spirv.storage_class<Image>>, %arg1: memref<1xvector<1xf32>, #spirv.storage_class<StorageBuffer>>) {784 %cst = arith.constant 0 : index785 // CHECK-NOT: spirv.Image786 // CHECK-NOT: spirv.ImageFetch787 %0 = memref.load %arg0[%cst] : memref<1xvector<1xf32>, #spirv.storage_class<Image>>788 memref.store %0, %arg1[%cst] : memref<1xvector<1xf32>, #spirv.storage_class<StorageBuffer>>789 return790 }791 792 // CHECK-LABEL: @load_non_perm_layout(793 func.func @load_non_perm_layout(%arg0: memref<2x4xf32, #non_permutation, #spirv.storage_class<Image>>, %arg1: memref<2x4xf32, #spirv.storage_class<StorageBuffer>>) {794 %x = arith.constant 3 : index795 %y = arith.constant 1 : index796 // CHECK-NOT: spirv.Image797 // CHECK-NOT: spirv.ImageFetch798 %0 = memref.load %arg0[%y, %x] : memref<2x4xf32, #non_permutation, #spirv.storage_class<Image>>799 memref.store %0, %arg1[%y, %x] : memref<2x4xf32, #spirv.storage_class<StorageBuffer>>800 return801 }802}803