299 lines · plain
1// RUN: mlir-opt %s --bubble-down-memory-space-casts | FileCheck %s2 3#map = affine_map<(d0, d1)[s0] -> (d1 * s0 + d0)>4 5// CHECK: #[[$ATTR_0:.+]] = affine_map<(d0, d1)[s0] -> (d1 * s0 + d0)>6// CHECK-LABEL: func.func @load_store(7// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,8// CHECK-SAME: %[[ARG1:.*]]: index) {9// CHECK: %[[VAL_0:.*]] = memref.load %[[ARG0]]{{\[}}%[[ARG1]]] : memref<?xf32, 1>10// CHECK: memref.store %[[VAL_0]], %[[ARG0]]{{\[}}%[[ARG1]]] : memref<?xf32, 1>11// CHECK: return12// CHECK: }13func.func @load_store(%arg0: memref<?xf32, 1>, %arg1: index) {14 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>15 %0 = memref.load %memspacecast[%arg1] : memref<?xf32>16 memref.store %0, %memspacecast[%arg1] : memref<?xf32>17 return18}19 20// CHECK-LABEL: func.func @load_store_unfoldable(21// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,22// CHECK-SAME: %[[ARG1:.*]]: index) {23// CHECK: %[[VAL_0:.*]] = memref.memory_space_cast %[[ARG0]] : memref<?xf32, 1> to memref<?xf32, 2>24// CHECK: %[[VAL_1:.*]] = memref.load %[[VAL_0]]{{\[}}%[[ARG1]]] : memref<?xf32, 2>25// CHECK: memref.store %[[VAL_1]], %[[VAL_0]]{{\[}}%[[ARG1]]] : memref<?xf32, 2>26// CHECK: return27// CHECK: }28func.func @load_store_unfoldable(%arg0: memref<?xf32, 1>, %arg1: index) {29 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32, 2>30 %0 = memref.load %memspacecast[%arg1] : memref<?xf32, 2>31 memref.store %0, %memspacecast[%arg1] : memref<?xf32, 2>32 return33}34 35// CHECK-LABEL: func.func @cast(36// CHECK-SAME: %[[ARG0:.*]]: memref<2xf32, 1>,37// CHECK-SAME: %[[ARG1:.*]]: memref<*xf32, 1>) -> (memref<*xf32>, memref<3x2xf32>) {38// CHECK: %[[VAL_0:.*]] = memref.cast %[[ARG0]] : memref<2xf32, 1> to memref<*xf32, 1>39// CHECK: %[[VAL_1:.*]] = memref.memory_space_cast %[[VAL_0]] : memref<*xf32, 1> to memref<*xf32>40// CHECK: %[[VAL_2:.*]] = memref.cast %[[ARG1]] : memref<*xf32, 1> to memref<3x2xf32, 1>41// CHECK: %[[VAL_3:.*]] = memref.memory_space_cast %[[VAL_2]] : memref<3x2xf32, 1> to memref<3x2xf32>42// CHECK: return %[[VAL_1]], %[[VAL_3]] : memref<*xf32>, memref<3x2xf32>43// CHECK: }44func.func @cast(%arg0: memref<2xf32, 1>, %arg1: memref<*xf32, 1>) -> (memref<*xf32>, memref<3x2xf32>) {45 %memspacecast = memref.memory_space_cast %arg0 : memref<2xf32, 1> to memref<2xf32>46 %1 = memref.cast %memspacecast : memref<2xf32> to memref<*xf32>47 %memspacecast_1 = memref.memory_space_cast %arg1 : memref<*xf32, 1> to memref<*xf32>48 %2 = memref.cast %memspacecast_1 : memref<*xf32> to memref<3x2xf32>49 return %1, %2 : memref<*xf32>, memref<3x2xf32>50}51 52// CHECK-LABEL: func.func @view(53// CHECK-SAME: %[[ARG0:.*]]: memref<?xi8, 1>,54// CHECK-SAME: %[[ARG1:.*]]: index, %[[ARG2:.*]]: index) -> memref<?x?xi8> {55// CHECK: %[[VAL_0:.*]] = arith.constant 100 : index56// CHECK: %[[VAL_1:.*]] = memref.view %[[ARG0]]{{\[}}%[[ARG1]]]{{\[}}%[[ARG2]], %[[VAL_0]]] : memref<?xi8, 1> to memref<?x?xi8, 1>57// CHECK: %[[VAL_2:.*]] = memref.memory_space_cast %[[VAL_1]] : memref<?x?xi8, 1> to memref<?x?xi8>58// CHECK: return %[[VAL_2]] : memref<?x?xi8>59// CHECK: }60func.func @view(%arg0: memref<?xi8, 1>, %arg1: index, %arg2: index) -> memref<?x?xi8> {61 %memspacecast = memref.memory_space_cast %arg0 : memref<?xi8, 1> to memref<?xi8>62 %c100 = arith.constant 100 : index63 %view = memref.view %memspacecast[%arg1][%arg2, %c100] : memref<?xi8> to memref<?x?xi8>64 return %view : memref<?x?xi8>65}66 67// CHECK-LABEL: func.func @subview(68// CHECK-SAME: %[[ARG0:.*]]: memref<?x?xf32, 1>,69// CHECK-SAME: %[[ARG1:.*]]: index) -> memref<8x2xf32, strided<[?, 2], offset: ?>> {70// CHECK: %[[VAL_0:.*]] = memref.subview %[[ARG0]][4, 2] [8, 2] [3, 2] : memref<?x?xf32, 1> to memref<8x2xf32, strided<[?, 2], offset: ?>, 1>71// CHECK: %[[VAL_1:.*]] = memref.memory_space_cast %[[VAL_0]] : memref<8x2xf32, strided<[?, 2], offset: ?>, 1> to memref<8x2xf32, strided<[?, 2], offset: ?>>72// CHECK: return %[[VAL_1]] : memref<8x2xf32, strided<[?, 2], offset: ?>>73// CHECK: }74func.func @subview(%arg0: memref<?x?xf32, 1>, %arg1: index) -> memref<8x2xf32, strided<[?, 2], offset: ?>> {75 %memspacecast = memref.memory_space_cast %arg0 : memref<?x?xf32, 1> to memref<?x?xf32>76 %subview = memref.subview %memspacecast[4, 2] [8, 2] [3, 2] : memref<?x?xf32> to memref<8x2xf32, strided<[?, 2], offset: ?>>77 return %subview : memref<8x2xf32, strided<[?, 2], offset: ?>>78}79 80// CHECK-LABEL: func.func @reinterpret_cast(81// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,82// CHECK-SAME: %[[ARG1:.*]]: index) -> memref<10x?xf32, strided<[?, 1], offset: ?>> {83// CHECK-DAG: %[[VAL_0:.*]] = arith.constant 10 : index84// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index85// CHECK: %[[VAL_2:.*]] = memref.reinterpret_cast %[[ARG0]] to offset: {{\[}}%[[VAL_1]]], sizes: [10, %[[VAL_0]]], strides: {{\[}}%[[VAL_0]], 1] : memref<?xf32, 1> to memref<10x?xf32, strided<[?, 1], offset: ?>, 1>86// CHECK: %[[VAL_3:.*]] = memref.memory_space_cast %[[VAL_2]] : memref<10x?xf32, strided<[?, 1], offset: ?>, 1> to memref<10x?xf32, strided<[?, 1], offset: ?>>87// CHECK: return %[[VAL_3]] : memref<10x?xf32, strided<[?, 1], offset: ?>>88// CHECK: }89func.func @reinterpret_cast(%arg0: memref<?xf32, 1>, %arg1: index) -> memref<10x?xf32, strided<[?, 1], offset: ?>> {90 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>91 %c0 = arith.constant 0 : index92 %c10 = arith.constant 10 : index93 %reinterpret_cast = memref.reinterpret_cast %memspacecast to offset: [%c0], sizes: [10, %c10], strides: [%c10, 1] : memref<?xf32> to memref<10x?xf32, strided<[?, 1], offset: ?>>94 return %reinterpret_cast : memref<10x?xf32, strided<[?, 1], offset: ?>>95}96 97// CHECK-LABEL: func.func @reshape(98// CHECK-SAME: %[[ARG0:.*]]: memref<?x?xf32, 1>,99// CHECK-SAME: %[[ARG1:.*]]: memref<1xindex>) -> memref<?xf32> {100// CHECK: %[[VAL_0:.*]] = memref.reshape %[[ARG0]](%[[ARG1]]) : (memref<?x?xf32, 1>, memref<1xindex>) -> memref<?xf32, 1>101// CHECK: %[[VAL_1:.*]] = memref.memory_space_cast %[[VAL_0]] : memref<?xf32, 1> to memref<?xf32>102// CHECK: return %[[VAL_1]] : memref<?xf32>103// CHECK: }104func.func @reshape(%arg0: memref<?x?xf32, 1>, %arg1: memref<1xindex>) -> memref<?xf32> {105 %memspacecast = memref.memory_space_cast %arg0 : memref<?x?xf32, 1> to memref<?x?xf32>106 %reshape = memref.reshape %memspacecast(%arg1) : (memref<?x?xf32>, memref<1xindex>) -> memref<?xf32>107 return %reshape : memref<?xf32>108}109 110// CHECK-LABEL: func.func @expand_shape(111// CHECK-SAME: %[[ARG0:.*]]: memref<12xf32, 1>) -> memref<3x4xf32> {112// CHECK: %[[VAL_0:.*]] = memref.expand_shape %[[ARG0]] {{\[\[}}0, 1]] output_shape [3, 4] : memref<12xf32, 1> into memref<3x4xf32, 1>113// CHECK: %[[VAL_1:.*]] = memref.memory_space_cast %[[VAL_0]] : memref<3x4xf32, 1> to memref<3x4xf32>114// CHECK: return %[[VAL_1]] : memref<3x4xf32>115// CHECK: }116func.func @expand_shape(%arg0: memref<12xf32, 1>) -> memref<3x4xf32> {117 %memspacecast = memref.memory_space_cast %arg0 : memref<12xf32, 1> to memref<12xf32>118 %expand_shape = memref.expand_shape %memspacecast [[0, 1]] output_shape [3, 4] : memref<12xf32> into memref<3x4xf32>119 return %expand_shape : memref<3x4xf32>120}121 122// CHECK-LABEL: func.func @collapse_shape(123// CHECK-SAME: %[[ARG0:.*]]: memref<3x4xf32, 1>) -> memref<12xf32> {124// CHECK: %[[VAL_0:.*]] = memref.collapse_shape %[[ARG0]] {{\[\[}}0, 1]] : memref<3x4xf32, 1> into memref<12xf32, 1>125// CHECK: %[[VAL_1:.*]] = memref.memory_space_cast %[[VAL_0]] : memref<12xf32, 1> to memref<12xf32>126// CHECK: return %[[VAL_1]] : memref<12xf32>127// CHECK: }128func.func @collapse_shape(%arg0: memref<3x4xf32, 1>) -> memref<12xf32> {129 %memspacecast = memref.memory_space_cast %arg0 : memref<3x4xf32, 1> to memref<3x4xf32>130 %collapse_shape = memref.collapse_shape %memspacecast [[0, 1]] : memref<3x4xf32> into memref<12xf32>131 return %collapse_shape : memref<12xf32>132}133 134// CHECK-LABEL: func.func @transpose(135// CHECK-SAME: %[[ARG0:.*]]: memref<?x?xf32, 1>) -> memref<?x?xf32, #[[$ATTR_0]]> {136// CHECK: %[[VAL_0:.*]] = memref.transpose %[[ARG0]] (d0, d1) -> (d1, d0) : memref<?x?xf32, 1> to memref<?x?xf32, #[[$ATTR_0]], 1>137// CHECK: %[[VAL_1:.*]] = memref.memory_space_cast %[[VAL_0]] : memref<?x?xf32, #[[$ATTR_0]], 1> to memref<?x?xf32, #[[$ATTR_0]]>138// CHECK: return %[[VAL_1]] : memref<?x?xf32, #[[$ATTR_0]]>139// CHECK: }140func.func @transpose(%arg0: memref<?x?xf32, 1>) -> memref<?x?xf32, #map> {141 %memspacecast = memref.memory_space_cast %arg0 : memref<?x?xf32, 1> to memref<?x?xf32>142 %transpose = memref.transpose %memspacecast (d0, d1) -> (d1, d0) : memref<?x?xf32> to memref<?x?xf32, #map>143 return %transpose : memref<?x?xf32, #map>144}145 146// CHECK-LABEL: func.func @atomic_rmw(147// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,148// CHECK-SAME: %[[ARG1:.*]]: index,149// CHECK-SAME: %[[ARG2:.*]]: f32) -> f32 {150// CHECK: %[[VAL_0:.*]] = memref.atomic_rmw addf %[[ARG2]], %[[ARG0]]{{\[}}%[[ARG1]]] : (f32, memref<?xf32, 1>) -> f32151// CHECK: return %[[VAL_0]] : f32152// CHECK: }153func.func @atomic_rmw(%arg0: memref<?xf32, 1>, %arg1: index, %arg2: f32) -> f32 {154 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>155 %0 = memref.atomic_rmw addf %arg2, %memspacecast[%arg1] : (f32, memref<?xf32>) -> f32156 return %0 : f32157}158 159// CHECK-LABEL: func.func @assume_alignment(160// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>) -> memref<?xf32> {161// CHECK: %[[VAL_0:.*]] = memref.assume_alignment %[[ARG0]], 16 : memref<?xf32, 1>162// CHECK: %[[VAL_1:.*]] = memref.memory_space_cast %[[VAL_0]] : memref<?xf32, 1> to memref<?xf32>163// CHECK: return %[[VAL_1]] : memref<?xf32>164// CHECK: }165func.func @assume_alignment(%arg0: memref<?xf32, 1>) -> memref<?xf32> {166 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>167 %1 = memref.assume_alignment %memspacecast, 16 : memref<?xf32>168 return %1 : memref<?xf32>169}170 171// CHECK-LABEL: func.func @op_with_cast_sequence(172// CHECK-SAME: %[[ARG0:.*]]: memref<4x4xf32, 1>,173// CHECK-SAME: %[[ARG1:.*]]: index,174// CHECK-SAME: %[[ARG2:.*]]: f32) -> memref<16xf32> {175// CHECK-DAG: %[[VAL_0:.*]] = arith.constant 4 : index176// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0 : index177// CHECK: %[[VAL_2:.*]] = memref.expand_shape %[[ARG0]] {{\[\[}}0], [1, 2]] output_shape [4, 2, 2] : memref<4x4xf32, 1> into memref<4x2x2xf32, 1>178// CHECK: %[[VAL_3:.*]] = memref.collapse_shape %[[VAL_2]] {{\[\[}}0, 1, 2]] : memref<4x2x2xf32, 1> into memref<16xf32, 1>179// CHECK: %[[VAL_4:.*]] = memref.memory_space_cast %[[VAL_3]] : memref<16xf32, 1> to memref<16xf32>180// CHECK: %[[VAL_5:.*]] = memref.load %[[VAL_3]]{{\[}}%[[VAL_1]]] : memref<16xf32, 1>181// CHECK: %[[VAL_6:.*]] = arith.addf %[[VAL_5]], %[[ARG2]] : f32182// CHECK: memref.store %[[VAL_6]], %[[VAL_3]]{{\[}}%[[VAL_1]]] : memref<16xf32, 1>183// CHECK: %[[VAL_7:.*]] = memref.atomic_rmw addf %[[ARG2]], %[[VAL_3]]{{\[}}%[[VAL_0]]] : (f32, memref<16xf32, 1>) -> f32184// CHECK: return %[[VAL_4]] : memref<16xf32>185// CHECK: }186func.func @op_with_cast_sequence(%arg0: memref<4x4xf32, 1>, %arg1: index, %arg2: f32) -> memref<16xf32> {187 %memspacecast = memref.memory_space_cast %arg0 : memref<4x4xf32, 1> to memref<4x4xf32>188 %c0 = arith.constant 0 : index189 %c4 = arith.constant 4 : index190 %expanded = memref.expand_shape %memspacecast [[0], [1, 2]] output_shape [4, 2, 2] : memref<4x4xf32> into memref<4x2x2xf32>191 %collapsed = memref.collapse_shape %expanded [[0, 1, 2]] : memref<4x2x2xf32> into memref<16xf32>192 %loaded = memref.load %collapsed[%c0] : memref<16xf32>193 %added = arith.addf %loaded, %arg2 : f32194 memref.store %added, %collapsed[%c0] : memref<16xf32>195 %atomic_result = memref.atomic_rmw addf %arg2, %collapsed[%c4] : (f32, memref<16xf32>) -> f32196 return %collapsed : memref<16xf32>197}198 199// CHECK-LABEL: func.func @transfer_read_write(200// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,201// CHECK-SAME: %[[ARG1:.*]]: index) {202// CHECK: %[[VAL_0:.*]] = arith.constant 0.000000e+00 : f32203// CHECK: %[[VAL_1:.*]] = vector.transfer_read %[[ARG0]]{{\[}}%[[ARG1]]], %[[VAL_0]] : memref<?xf32, 1>, vector<4xf32>204// CHECK: vector.transfer_write %[[VAL_1]], %[[ARG0]]{{\[}}%[[ARG1]]] : vector<4xf32>, memref<?xf32, 1>205// CHECK: return206// CHECK: }207func.func @transfer_read_write(%arg0: memref<?xf32, 1>, %arg1: index) {208 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>209 %c0 = arith.constant 0.0 : f32210 %0 = vector.transfer_read %memspacecast[%arg1], %c0 : memref<?xf32>, vector<4xf32>211 vector.transfer_write %0, %memspacecast[%arg1] : vector<4xf32>, memref<?xf32>212 return213}214 215// NOTE: The operations disappear because they can get folded.216// CHECK-LABEL: func.func @transfer_read_write_tensor(217// CHECK-SAME: %[[ARG0:.*]]: tensor<?xf32>,218// CHECK-SAME: %[[ARG1:.*]]: index) -> tensor<?xf32> {219// CHECK: return %[[ARG0]] : tensor<?xf32>220// CHECK: }221func.func @transfer_read_write_tensor(%arg0: tensor<?xf32>, %arg1: index) -> tensor<?xf32> {222 %c0 = arith.constant 0.0 : f32223 %0 = vector.transfer_read %arg0[%arg1], %c0 : tensor<?xf32>, vector<4xf32>224 %1 = vector.transfer_write %0, %arg0[%arg1] : vector<4xf32>, tensor<?xf32>225 return %1 : tensor<?xf32>226}227 228// CHECK-LABEL: func.func @vector_load_store(229// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,230// CHECK-SAME: %[[ARG1:.*]]: index) {231// CHECK: %[[VAL_0:.*]] = vector.load %[[ARG0]]{{\[}}%[[ARG1]]] : memref<?xf32, 1>, vector<4xf32>232// CHECK: vector.store %[[VAL_0]], %[[ARG0]]{{\[}}%[[ARG1]]] : memref<?xf32, 1>, vector<4xf32>233// CHECK: return234// CHECK: }235func.func @vector_load_store(%arg0: memref<?xf32, 1>, %arg1: index) {236 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>237 %0 = vector.load %memspacecast[%arg1] : memref<?xf32>, vector<4xf32>238 vector.store %0, %memspacecast[%arg1] : memref<?xf32>, vector<4xf32>239 return240}241 242// CHECK-LABEL: func.func @masked_load_store(243// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,244// CHECK-SAME: %[[ARG1:.*]]: index) {245// CHECK-DAG: %[[VAL_0:.*]] = arith.constant dense<0.000000e+00> : vector<4xf32>246// CHECK-DAG: %[[VAL_1:.*]] = arith.constant dense<[true, true, false, false]> : vector<4xi1>247// CHECK: %[[VAL_2:.*]] = vector.maskedload %[[ARG0]]{{\[}}%[[ARG1]]], %[[VAL_1]], %[[VAL_0]] : memref<?xf32, 1>, vector<4xi1>, vector<4xf32> into vector<4xf32>248// CHECK: vector.maskedstore %[[ARG0]]{{\[}}%[[ARG1]]], %[[VAL_1]], %[[VAL_2]] : memref<?xf32, 1>, vector<4xi1>, vector<4xf32>249// CHECK: return250// CHECK: }251func.func @masked_load_store(%arg0: memref<?xf32, 1>, %arg1: index) {252 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>253 %mask = arith.constant dense<[true, true, false, false]> : vector<4xi1>254 %passthrough = arith.constant dense<0.0> : vector<4xf32>255 %0 = vector.maskedload %memspacecast[%arg1], %mask, %passthrough : memref<?xf32>, vector<4xi1>, vector<4xf32> into vector<4xf32>256 vector.maskedstore %memspacecast[%arg1], %mask, %0 : memref<?xf32>, vector<4xi1>, vector<4xf32>257 return258}259 260// CHECK-LABEL: func.func @gather_scatter(261// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,262// CHECK-SAME: %[[ARG1:.*]]: index) {263// CHECK-DAG: %[[VAL_0:.*]] = arith.constant dense<0.000000e+00> : vector<4xf32>264// CHECK-DAG: %[[VAL_1:.*]] = arith.constant dense<true> : vector<4xi1>265// CHECK-DAG: %[[VAL_2:.*]] = arith.constant dense<[0, 1, 2, 3]> : vector<4xindex>266// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index267// CHECK: %[[VAL_4:.*]] = vector.gather %[[ARG0]]{{\[}}%[[VAL_3]]] {{\[}}%[[VAL_2]]], %[[VAL_1]], %[[VAL_0]] : memref<?xf32, 1>, vector<4xindex>, vector<4xi1>, vector<4xf32> into vector<4xf32>268// CHECK: vector.scatter %[[ARG0]]{{\[}}%[[VAL_3]]] {{\[}}%[[VAL_2]]], %[[VAL_1]], %[[VAL_4]] : memref<?xf32, 1>, vector<4xindex>, vector<4xi1>, vector<4xf32>269// CHECK: return270// CHECK: }271func.func @gather_scatter(%arg0: memref<?xf32, 1>, %arg1: index) {272 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>273 %c0 = arith.constant 0 : index274 %indices = arith.constant dense<[0, 1, 2, 3]> : vector<4xindex>275 %mask = arith.constant dense<true> : vector<4xi1>276 %passthrough = arith.constant dense<0.0> : vector<4xf32>277 %0 = vector.gather %memspacecast[%c0] [%indices], %mask, %passthrough : memref<?xf32>, vector<4xindex>, vector<4xi1>, vector<4xf32> into vector<4xf32>278 vector.scatter %memspacecast[%c0] [%indices], %mask, %0 : memref<?xf32>, vector<4xindex>, vector<4xi1>, vector<4xf32>279 return280}281 282// CHECK-LABEL: func.func @expandload_compressstore(283// CHECK-SAME: %[[ARG0:.*]]: memref<?xf32, 1>,284// CHECK-SAME: %[[ARG1:.*]]: index) {285// CHECK-DAG: %[[VAL_0:.*]] = arith.constant dense<0.000000e+00> : vector<4xf32>286// CHECK-DAG: %[[VAL_1:.*]] = arith.constant dense<[true, true, false, false]> : vector<4xi1>287// CHECK: %[[VAL_2:.*]] = vector.expandload %[[ARG0]]{{\[}}%[[ARG1]]], %[[VAL_1]], %[[VAL_0]] : memref<?xf32, 1>, vector<4xi1>, vector<4xf32> into vector<4xf32>288// CHECK: vector.compressstore %[[ARG0]]{{\[}}%[[ARG1]]], %[[VAL_1]], %[[VAL_2]] : memref<?xf32, 1>, vector<4xi1>, vector<4xf32>289// CHECK: return290// CHECK: }291func.func @expandload_compressstore(%arg0: memref<?xf32, 1>, %arg1: index) {292 %memspacecast = memref.memory_space_cast %arg0 : memref<?xf32, 1> to memref<?xf32>293 %mask = arith.constant dense<[true, true, false, false]> : vector<4xi1>294 %passthrough = arith.constant dense<0.0> : vector<4xf32>295 %0 = vector.expandload %memspacecast[%arg1], %mask, %passthrough : memref<?xf32>, vector<4xi1>, vector<4xf32> into vector<4xf32>296 vector.compressstore %memspacecast[%arg1], %mask, %0 : memref<?xf32>, vector<4xi1>, vector<4xf32>297 return298}299