| blob | ccb75b8a606a29b47cc46aa3b05950ec113ffb14 |
1 // RUN: mlir-opt %s -convert-vector-to-llvm -split-input-file | FileCheck %s
4 func @bitcast_f32_to_i32_vector_0d(%input: vector<f32>) -> vector<i32> {
5 %0 = vector.bitcast %input : vector<f32> to vector<i32>
6 return %0 : vector<i32>
7 }
9 // CHECK-LABEL: @bitcast_f32_to_i32_vector_0d
10 // CHECK-SAME: %[[input:.*]]: vector<f32>
11 // CHECK: %[[vec_f32_1d:.*]] = builtin.unrealized_conversion_cast %[[input]] : vector<f32> to vector<1xf32>
12 // CHECK: %[[vec_i32_1d:.*]] = llvm.bitcast %[[vec_f32_1d]] : vector<1xf32> to vector<1xi32>
13 // CHECK: %[[vec_i32_0d:.*]] = builtin.unrealized_conversion_cast %[[vec_i32_1d]] : vector<1xi32> to vector<i32>
14 // CHECK: return %[[vec_i32_0d]] : vector<i32>
16 // -----
18 func @bitcast_f32_to_i32_vector(%input: vector<16xf32>) -> vector<16xi32> {
19 %0 = vector.bitcast %input : vector<16xf32> to vector<16xi32>
20 return %0 : vector<16xi32>
21 }
23 // CHECK-LABEL: @bitcast_f32_to_i32_vector
24 // CHECK-SAME: %[[input:.*]]: vector<16xf32>
25 // CHECK: llvm.bitcast %[[input]] : vector<16xf32> to vector<16xi32>
27 // -----
29 func @bitcast_i8_to_f32_vector(%input: vector<64xi8>) -> vector<16xf32> {
30 %0 = vector.bitcast %input : vector<64xi8> to vector<16xf32>
31 return %0 : vector<16xf32>
32 }
34 // CHECK-LABEL: @bitcast_i8_to_f32_vector
35 // CHECK-SAME: %[[input:.*]]: vector<64xi8>
36 // CHECK: llvm.bitcast %[[input]] : vector<64xi8> to vector<16xf32>
38 // -----
40 func @bitcast_index_to_i8_vector(%input: vector<16xindex>) -> vector<128xi8> {
41 %0 = vector.bitcast %input : vector<16xindex> to vector<128xi8>
42 return %0 : vector<128xi8>
43 }
45 // CHECK-LABEL: @bitcast_index_to_i8_vector
46 // CHECK-SAME: %[[input:.*]]: vector<16xindex>
47 // CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[input]] : vector<16xindex> to vector<16xi64>
48 // CHECK: llvm.bitcast %[[T0]] : vector<16xi64> to vector<128xi8>
50 // -----
52 func @broadcast_vec0d_from_f32(%arg0: f32) -> vector<f32> {
53 %0 = vector.broadcast %arg0 : f32 to vector<f32>
54 return %0 : vector<f32>
55 }
56 // CHECK-LABEL: @broadcast_vec0d_from_f32
57 // CHECK-SAME: %[[A:.*]]: f32)
58 // CHECK: %[[T0:.*]] = splat %[[A]] : vector<f32>
59 // CHECK: return %[[T0]] : vector<f32>
61 // -----
63 func @broadcast_vec0d_from_vec0d(%arg0: vector<f32>) -> vector<f32> {
64 %0 = vector.broadcast %arg0 : vector<f32> to vector<f32>
65 return %0 : vector<f32>
66 }
67 // CHECK-LABEL: @broadcast_vec0d_from_vec0d(
68 // CHECK-SAME: %[[A:.*]]: vector<f32>)
69 // CHECK: return %[[A]] : vector<f32>
71 // -----
73 func @broadcast_vec1d_from_f32(%arg0: f32) -> vector<2xf32> {
74 %0 = vector.broadcast %arg0 : f32 to vector<2xf32>
75 return %0 : vector<2xf32>
76 }
77 // CHECK-LABEL: @broadcast_vec1d_from_f32
78 // CHECK-SAME: %[[A:.*]]: f32)
79 // CHECK: %[[T0:.*]] = splat %[[A]] : vector<2xf32>
80 // CHECK: return %[[T0]] : vector<2xf32>
82 // -----
84 func @broadcast_vec1d_from_index(%arg0: index) -> vector<2xindex> {
85 %0 = vector.broadcast %arg0 : index to vector<2xindex>
86 return %0 : vector<2xindex>
87 }
88 // CHECK-LABEL: @broadcast_vec1d_from_index
89 // CHECK-SAME: %[[A:.*]]: index)
90 // CHECK: %[[T0:.*]] = splat %[[A]] : vector<2xindex>
91 // CHECK: return %[[T0]] : vector<2xindex>
93 // -----
95 func @broadcast_vec2d_from_scalar(%arg0: f32) -> vector<2x3xf32> {
96 %0 = vector.broadcast %arg0 : f32 to vector<2x3xf32>
97 return %0 : vector<2x3xf32>
98 }
99 // CHECK-LABEL: @broadcast_vec2d_from_scalar(
100 // CHECK-SAME: %[[A:.*]]: f32)
101 // CHECK: %[[T0:.*]] = splat %[[A]] : vector<2x3xf32>
102 // CHECK: return %[[T0]] : vector<2x3xf32>
104 // -----
106 func @broadcast_vec3d_from_scalar(%arg0: f32) -> vector<2x3x4xf32> {
107 %0 = vector.broadcast %arg0 : f32 to vector<2x3x4xf32>
108 return %0 : vector<2x3x4xf32>
109 }
110 // CHECK-LABEL: @broadcast_vec3d_from_scalar(
111 // CHECK-SAME: %[[A:.*]]: f32)
112 // CHECK: %[[T0:.*]] = splat %[[A]] : vector<2x3x4xf32>
113 // CHECK: return %[[T0]] : vector<2x3x4xf32>
115 // -----
117 func @broadcast_vec1d_from_vec1d(%arg0: vector<2xf32>) -> vector<2xf32> {
118 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<2xf32>
119 return %0 : vector<2xf32>
120 }
121 // CHECK-LABEL: @broadcast_vec1d_from_vec1d(
122 // CHECK-SAME: %[[A:.*]]: vector<2xf32>)
123 // CHECK: return %[[A]] : vector<2xf32>
125 // -----
127 func @broadcast_vec2d_from_vec0d(%arg0: vector<f32>) -> vector<3x2xf32> {
128 %0 = vector.broadcast %arg0 : vector<f32> to vector<3x2xf32>
129 return %0 : vector<3x2xf32>
130 }
131 // CHECK-LABEL: @broadcast_vec2d_from_vec0d(
132 // CHECK-SAME: %[[A:.*]]: vector<f32>)
133 // CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<f32> to vector<1xf32>
134 // CHECK: %[[T1:.*]] = arith.constant dense<0.000000e+00> : vector<3x2xf32>
135 // CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>>
136 // CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : index) : i64
137 // CHECK: %[[T5:.*]] = llvm.extractelement %[[T0]][%[[T4]] : i64] : vector<1xf32>
138 // CHECK: %[[T6:.*]] = splat %[[T5]] : vector<2xf32>
139 // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T6]], %[[T2]][0] : !llvm.array<3 x vector<2xf32>>
140 // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T6]], %[[T7]][1] : !llvm.array<3 x vector<2xf32>>
141 // CHECK: %[[T9:.*]] = llvm.insertvalue %[[T6]], %[[T8]][2] : !llvm.array<3 x vector<2xf32>>
142 // CHECK: %[[T10:.*]] = builtin.unrealized_conversion_cast %[[T9]] : !llvm.array<3 x vector<2xf32>> to vector<3x2xf32>
143 // CHECK: return %[[T10]] : vector<3x2xf32>
145 // -----
147 func @broadcast_vec2d_from_vec1d(%arg0: vector<2xf32>) -> vector<3x2xf32> {
148 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<3x2xf32>
149 return %0 : vector<3x2xf32>
150 }
151 // CHECK-LABEL: @broadcast_vec2d_from_vec1d(
152 // CHECK-SAME: %[[A:.*]]: vector<2xf32>)
153 // CHECK: %[[T0:.*]] = arith.constant dense<0.000000e+00> : vector<3x2xf32>
154 // CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>>
155 // CHECK: %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T1]][0] : !llvm.array<3 x vector<2xf32>>
156 // CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][1] : !llvm.array<3 x vector<2xf32>>
157 // CHECK: %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][2] : !llvm.array<3 x vector<2xf32>>
158 // CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : !llvm.array<3 x vector<2xf32>> to vector<3x2xf32>
159 // CHECK: return %[[T5]] : vector<3x2xf32>
161 // -----
163 func @broadcast_vec2d_from_index_vec1d(%arg0: vector<2xindex>) -> vector<3x2xindex> {
164 %0 = vector.broadcast %arg0 : vector<2xindex> to vector<3x2xindex>
165 return %0 : vector<3x2xindex>
166 }
167 // CHECK-LABEL: @broadcast_vec2d_from_index_vec1d(
168 // CHECK-SAME: %[[A:.*]]: vector<2xindex>)
169 // CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64>
170 // CHECK: %[[T0:.*]] = arith.constant dense<0> : vector<3x2xindex>
171 // CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<3x2xindex> to !llvm.array<3 x vector<2xi64>>
172 // CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][0] : !llvm.array<3 x vector<2xi64>>
174 // CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %{{.*}} : !llvm.array<3 x vector<2xi64>> to vector<3x2xindex>
175 // CHECK: return %[[T4]] : vector<3x2xindex>
177 // -----
179 func @broadcast_vec3d_from_vec1d(%arg0: vector<2xf32>) -> vector<4x3x2xf32> {
180 %0 = vector.broadcast %arg0 : vector<2xf32> to vector<4x3x2xf32>
181 return %0 : vector<4x3x2xf32>
182 }
183 // CHECK-LABEL: @broadcast_vec3d_from_vec1d(
184 // CHECK-SAME: %[[A:.*]]: vector<2xf32>)
185 // CHECK: %[[T0:.*]] = arith.constant dense<0.000000e+00> : vector<3x2xf32>
186 // CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>>
187 // CHECK: %[[T1:.*]] = arith.constant dense<0.000000e+00> : vector<4x3x2xf32>
188 // CHECK: %[[T6:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>>
190 // CHECK: %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][0] : !llvm.array<3 x vector<2xf32>>
191 // CHECK: %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][1] : !llvm.array<3 x vector<2xf32>>
192 // CHECK: %[[T5:.*]] = llvm.insertvalue %[[A]], %[[T4]][2] : !llvm.array<3 x vector<2xf32>>
194 // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T5]], %[[T6]][0] : !llvm.array<4 x array<3 x vector<2xf32>>>
195 // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T5]], %[[T7]][1] : !llvm.array<4 x array<3 x vector<2xf32>>>
196 // CHECK: %[[T9:.*]] = llvm.insertvalue %[[T5]], %[[T8]][2] : !llvm.array<4 x array<3 x vector<2xf32>>>
197 // CHECK: %[[T10:.*]] = llvm.insertvalue %[[T5]], %[[T9]][3] : !llvm.array<4 x array<3 x vector<2xf32>>>
199 // CHECK: %[[T11:.*]] = builtin.unrealized_conversion_cast %[[T10]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32>
200 // CHECK: return %[[T11]] : vector<4x3x2xf32>
202 // -----
204 func @broadcast_vec3d_from_vec2d(%arg0: vector<3x2xf32>) -> vector<4x3x2xf32> {
205 %0 = vector.broadcast %arg0 : vector<3x2xf32> to vector<4x3x2xf32>
206 return %0 : vector<4x3x2xf32>
207 }
208 // CHECK-LABEL: @broadcast_vec3d_from_vec2d(
209 // CHECK-SAME: %[[A:.*]]: vector<3x2xf32>)
210 // CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>>
211 // CHECK: %[[T0:.*]] = arith.constant dense<0.000000e+00> : vector<4x3x2xf32>
212 // CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>>
213 // CHECK: %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][0] : !llvm.array<4 x array<3 x vector<2xf32>>>
214 // CHECK: %[[T5:.*]] = llvm.insertvalue %[[T1]], %[[T3]][1] : !llvm.array<4 x array<3 x vector<2xf32>>>
215 // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T1]], %[[T5]][2] : !llvm.array<4 x array<3 x vector<2xf32>>>
216 // CHECK: %[[T9:.*]] = llvm.insertvalue %[[T1]], %[[T7]][3] : !llvm.array<4 x array<3 x vector<2xf32>>>
217 // CHECK: %[[T10:.*]] = builtin.unrealized_conversion_cast %[[T9]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32>
218 // CHECK: return %[[T10]] : vector<4x3x2xf32>
221 // -----
223 func @broadcast_stretch(%arg0: vector<1xf32>) -> vector<4xf32> {
224 %0 = vector.broadcast %arg0 : vector<1xf32> to vector<4xf32>
225 return %0 : vector<4xf32>
226 }
227 // CHECK-LABEL: @broadcast_stretch(
228 // CHECK-SAME: %[[A:.*]]: vector<1xf32>)
229 // CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : i64
230 // CHECK: %[[T2:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T1]] : i64] : vector<1xf32>
231 // CHECK: %[[T3:.*]] = splat %[[T2]] : vector<4xf32>
232 // CHECK: return %[[T3]] : vector<4xf32>
234 // -----
236 func @broadcast_stretch_at_start(%arg0: vector<1x4xf32>) -> vector<3x4xf32> {
237 %0 = vector.broadcast %arg0 : vector<1x4xf32> to vector<3x4xf32>
238 return %0 : vector<3x4xf32>
239 }
240 // CHECK-LABEL: @broadcast_stretch_at_start(
241 // CHECK-SAME: %[[A:.*]]: vector<1x4xf32>)
242 // CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>>
243 // CHECK: %[[T1:.*]] = arith.constant dense<0.000000e+00> : vector<3x4xf32>
244 // CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<3x4xf32> to !llvm.array<3 x vector<4xf32>>
245 // CHECK: %[[T3:.*]] = llvm.extractvalue %[[T2]][0] : !llvm.array<1 x vector<4xf32>>
246 // CHECK: %[[T5:.*]] = llvm.insertvalue %[[T3]], %[[T4]][0] : !llvm.array<3 x vector<4xf32>>
247 // CHECK: %[[T6:.*]] = llvm.insertvalue %[[T3]], %[[T5]][1] : !llvm.array<3 x vector<4xf32>>
248 // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T3]], %[[T6]][2] : !llvm.array<3 x vector<4xf32>>
249 // CHECK: %[[T8:.*]] = builtin.unrealized_conversion_cast %[[T7]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32>
250 // CHECK: return %[[T8]] : vector<3x4xf32>
252 // -----
254 func @broadcast_stretch_at_end(%arg0: vector<4x1xf32>) -> vector<4x3xf32> {
255 %0 = vector.broadcast %arg0 : vector<4x1xf32> to vector<4x3xf32>
256 return %0 : vector<4x3xf32>
257 }
258 // CHECK-LABEL: @broadcast_stretch_at_end(
259 // CHECK-SAME: %[[A:.*]]: vector<4x1xf32>)
260 // CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1xf32> to !llvm.array<4 x vector<1xf32>>
261 // CHECK: %[[T1:.*]] = arith.constant dense<0.000000e+00> : vector<4x3xf32>
262 // CHECK: %[[T7:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<4x3xf32> to !llvm.array<4 x vector<3xf32>>
263 // CHECK: %[[T3:.*]] = llvm.extractvalue %[[T2]][0] : !llvm.array<4 x vector<1xf32>>
264 // CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i64) : i64
265 // CHECK: %[[T5:.*]] = llvm.extractelement %[[T3]]{{\[}}%[[T4]] : i64] : vector<1xf32>
266 // CHECK: %[[T6:.*]] = splat %[[T5]] : vector<3xf32>
267 // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T6]], %[[T7]][0] : !llvm.array<4 x vector<3xf32>>
268 // CHECK: %[[T10:.*]] = llvm.extractvalue %[[T2]][1] : !llvm.array<4 x vector<1xf32>>
269 // CHECK: %[[T11:.*]] = llvm.mlir.constant(0 : i64) : i64
270 // CHECK: %[[T12:.*]] = llvm.extractelement %[[T10]]{{\[}}%[[T11]] : i64] : vector<1xf32>
271 // CHECK: %[[T13:.*]] = splat %[[T12]] : vector<3xf32>
272 // CHECK: %[[T14:.*]] = llvm.insertvalue %[[T13]], %[[T8]][1] : !llvm.array<4 x vector<3xf32>>
273 // CHECK: %[[T16:.*]] = llvm.extractvalue %[[T2]][2] : !llvm.array<4 x vector<1xf32>>
274 // CHECK: %[[T17:.*]] = llvm.mlir.constant(0 : i64) : i64
275 // CHECK: %[[T18:.*]] = llvm.extractelement %[[T16]]{{\[}}%[[T17]] : i64] : vector<1xf32>
276 // CHECK: %[[T19:.*]] = splat %[[T18]] : vector<3xf32>
277 // CHECK: %[[T20:.*]] = llvm.insertvalue %[[T19]], %[[T14]][2] : !llvm.array<4 x vector<3xf32>>
278 // CHECK: %[[T22:.*]] = llvm.extractvalue %[[T2]][3] : !llvm.array<4 x vector<1xf32>>
279 // CHECK: %[[T23:.*]] = llvm.mlir.constant(0 : i64) : i64
280 // CHECK: %[[T24:.*]] = llvm.extractelement %[[T22]]{{\[}}%[[T23]] : i64] : vector<1xf32>
281 // CHECK: %[[T25:.*]] = splat %[[T24]] : vector<3xf32>
282 // CHECK: %[[T26:.*]] = llvm.insertvalue %[[T25]], %[[T20]][3] : !llvm.array<4 x vector<3xf32>>
283 // CHECK: %[[T27:.*]] = builtin.unrealized_conversion_cast %[[T26]] : !llvm.array<4 x vector<3xf32>> to vector<4x3xf32>
284 // CHECK: return %[[T27]] : vector<4x3xf32>
286 // -----
288 func @broadcast_stretch_in_middle(%arg0: vector<4x1x2xf32>) -> vector<4x3x2xf32> {
289 %0 = vector.broadcast %arg0 : vector<4x1x2xf32> to vector<4x3x2xf32>
290 return %0 : vector<4x3x2xf32>
291 }
292 // CHECK-LABEL: @broadcast_stretch_in_middle(
293 // CHECK-SAME: %[[A:.*]]: vector<4x1x2xf32>) -> vector<4x3x2xf32> {
294 // CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4x1x2xf32> to !llvm.array<4 x array<1 x vector<2xf32>>>
295 // CHECK: %[[T1:.*]] = arith.constant dense<0.000000e+00> : vector<4x3x2xf32>
296 // CHECK: %[[T9:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<4x3x2xf32> to !llvm.array<4 x array<3 x vector<2xf32>>>
297 // CHECK: %[[T2:.*]] = arith.constant dense<0.000000e+00> : vector<3x2xf32>
298 // CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<3x2xf32> to !llvm.array<3 x vector<2xf32>>
299 // CHECK: %[[T4:.*]] = llvm.extractvalue %[[T3]][0, 0] : !llvm.array<4 x array<1 x vector<2xf32>>>
300 // CHECK: %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][0] : !llvm.array<3 x vector<2xf32>>
301 // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][1] : !llvm.array<3 x vector<2xf32>>
302 // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][2] : !llvm.array<3 x vector<2xf32>>
303 // CHECK: %[[T10:.*]] = llvm.insertvalue %[[T8]], %[[T9]][0] : !llvm.array<4 x array<3 x vector<2xf32>>>
304 // CHECK: %[[T12:.*]] = llvm.extractvalue %[[T3]][1, 0] : !llvm.array<4 x array<1 x vector<2xf32>>>
305 // CHECK: %[[T14:.*]] = llvm.insertvalue %[[T12]], %[[T5]][0] : !llvm.array<3 x vector<2xf32>>
306 // CHECK: %[[T15:.*]] = llvm.insertvalue %[[T12]], %[[T14]][1] : !llvm.array<3 x vector<2xf32>>
307 // CHECK: %[[T16:.*]] = llvm.insertvalue %[[T12]], %[[T15]][2] : !llvm.array<3 x vector<2xf32>>
308 // CHECK: %[[T17:.*]] = llvm.insertvalue %[[T16]], %[[T10]][1] : !llvm.array<4 x array<3 x vector<2xf32>>>
309 // CHECK: %[[T19:.*]] = llvm.extractvalue %[[T3]][2, 0] : !llvm.array<4 x array<1 x vector<2xf32>>>
310 // CHECK: %[[T21:.*]] = llvm.insertvalue %[[T19]], %[[T5]][0] : !llvm.array<3 x vector<2xf32>>
311 // CHECK: %[[T22:.*]] = llvm.insertvalue %[[T19]], %[[T21]][1] : !llvm.array<3 x vector<2xf32>>
312 // CHECK: %[[T23:.*]] = llvm.insertvalue %[[T19]], %[[T22]][2] : !llvm.array<3 x vector<2xf32>>
313 // CHECK: %[[T24:.*]] = llvm.insertvalue %[[T23]], %[[T17]][2] : !llvm.array<4 x array<3 x vector<2xf32>>>
314 // CHECK: %[[T26:.*]] = llvm.extractvalue %[[T3]][3, 0] : !llvm.array<4 x array<1 x vector<2xf32>>>
315 // CHECK: %[[T28:.*]] = llvm.insertvalue %[[T26]], %[[T5]][0] : !llvm.array<3 x vector<2xf32>>
316 // CHECK: %[[T29:.*]] = llvm.insertvalue %[[T26]], %[[T28]][1] : !llvm.array<3 x vector<2xf32>>
317 // CHECK: %[[T30:.*]] = llvm.insertvalue %[[T26]], %[[T29]][2] : !llvm.array<3 x vector<2xf32>>
318 // CHECK: %[[T31:.*]] = llvm.insertvalue %[[T30]], %[[T24]][3] : !llvm.array<4 x array<3 x vector<2xf32>>>
319 // CHECK: %[[T32:.*]] = builtin.unrealized_conversion_cast %[[T31]] : !llvm.array<4 x array<3 x vector<2xf32>>> to vector<4x3x2xf32>
320 // CHECK: return %[[T32]] : vector<4x3x2xf32>
322 // -----
324 func @outerproduct(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<2x3xf32> {
325 %2 = vector.outerproduct %arg0, %arg1 : vector<2xf32>, vector<3xf32>
326 return %2 : vector<2x3xf32>
327 }
328 // CHECK-LABEL: @outerproduct(
329 // CHECK-SAME: %[[A:.*]]: vector<2xf32>,
330 // CHECK-SAME: %[[B:.*]]: vector<3xf32>)
331 // CHECK: %[[T2:.*]] = arith.constant dense<0.000000e+00> : vector<2x3xf32>
332 // CHECK: %[[T7:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>>
333 // CHECK: %[[T3:.*]] = llvm.mlir.constant(0 : i64) : i64
334 // CHECK: %[[T4:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T3]] : i64] : vector<2xf32>
335 // CHECK: %[[T5:.*]] = splat %[[T4]] : vector<3xf32>
336 // CHECK: %[[T6:.*]] = arith.mulf %[[T5]], %[[B]] : vector<3xf32>
337 // CHECK: %[[T8:.*]] = llvm.insertvalue %[[T6]], %[[T7]][0] : !llvm.array<2 x vector<3xf32>>
338 // CHECK: %[[T9:.*]] = llvm.mlir.constant(1 : i64) : i64
339 // CHECK: %[[T10:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T9]] : i64] : vector<2xf32>
340 // CHECK: %[[T11:.*]] = splat %[[T10]] : vector<3xf32>
341 // CHECK: %[[T12:.*]] = arith.mulf %[[T11]], %[[B]] : vector<3xf32>
342 // CHECK: %[[T13:.*]] = llvm.insertvalue %[[T12]], %[[T8]][1] : !llvm.array<2 x vector<3xf32>>
343 // CHECK: %[[T14:.*]] = builtin.unrealized_conversion_cast %[[T13]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32>
344 // CHECK: return %[[T14]] : vector<2x3xf32>
346 // -----
348 func @outerproduct_index(%arg0: vector<2xindex>, %arg1: vector<3xindex>) -> vector<2x3xindex> {
349 %2 = vector.outerproduct %arg0, %arg1 : vector<2xindex>, vector<3xindex>
350 return %2 : vector<2x3xindex>
351 }
352 // CHECK-LABEL: @outerproduct_index(
353 // CHECK-SAME: %[[A:.*]]: vector<2xindex>,
354 // CHECK-SAME: %[[B:.*]]: vector<3xindex>)
355 // CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64>
356 // CHECK: %[[T0:.*]] = arith.constant dense<0> : vector<2x3xindex>
357 // CHECK: %[[T8:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<2x3xindex> to !llvm.array<2 x vector<3xi64>>
358 // CHECK: %[[T2:.*]] = llvm.mlir.constant(0 : i64) : i64
359 // CHECK: %[[T3:.*]] = llvm.extractelement %[[T1]]{{\[}}%[[T2]] : i64] : vector<2xi64>
360 // CHECK: %[[T4:.*]] = builtin.unrealized_conversion_cast %[[T3]] : i64 to index
361 // CHECK: %[[T5:.*]] = splat %[[T4]] : vector<3xindex>
362 // CHECK: %[[T6:.*]] = arith.muli %[[T5]], %[[B]] : vector<3xindex>
363 // CHECK: %[[T7:.*]] = builtin.unrealized_conversion_cast %[[T6]] : vector<3xindex> to vector<3xi64>
364 // CHECK: %{{.*}} = llvm.insertvalue %[[T7]], %[[T8]][0] : !llvm.array<2 x vector<3xi64>>
366 // -----
368 func @outerproduct_add(%arg0: vector<2xf32>, %arg1: vector<3xf32>, %arg2: vector<2x3xf32>) -> vector<2x3xf32> {
369 %2 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32>
370 return %2 : vector<2x3xf32>
371 }
372 // CHECK-LABEL: @outerproduct_add(
373 // CHECK-SAME: %[[A:.*]]: vector<2xf32>,
374 // CHECK-SAME: %[[B:.*]]: vector<3xf32>,
375 // CHECK-SAME: %[[C:.*]]: vector<2x3xf32>) -> vector<2x3xf32>
376 // CHECK: %[[T7:.*]] = builtin.unrealized_conversion_cast %[[C]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>>
377 // CHECK: %[[T3:.*]] = arith.constant dense<0.000000e+00> : vector<2x3xf32>
378 // CHECK: %[[T10:.*]] = builtin.unrealized_conversion_cast %[[T3]] : vector<2x3xf32> to !llvm.array<2 x vector<3xf32>>
379 // CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i64) : i64
380 // CHECK: %[[T5:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T4]] : i64] : vector<2xf32>
381 // CHECK: %[[T6:.*]] = splat %[[T5]] : vector<3xf32>
382 // CHECK: %[[T8:.*]] = llvm.extractvalue %[[T7]][0] : !llvm.array<2 x vector<3xf32>>
383 // CHECK: %[[T9:.*]] = "llvm.intr.fmuladd"(%[[T6]], %[[B]], %[[T8]]) : (vector<3xf32>, vector<3xf32>, vector<3xf32>) -> vector<3xf32>
384 // CHECK: %[[T11:.*]] = llvm.insertvalue %[[T9]], %[[T10]][0] : !llvm.array<2 x vector<3xf32>>
385 // CHECK: %[[T12:.*]] = llvm.mlir.constant(1 : i64) : i64
386 // CHECK: %[[T13:.*]] = llvm.extractelement %[[A]]{{\[}}%[[T12]] : i64] : vector<2xf32>
387 // CHECK: %[[T14:.*]] = splat %[[T13]] : vector<3xf32>
388 // CHECK: %[[T16:.*]] = llvm.extractvalue %[[T7]][1] : !llvm.array<2 x vector<3xf32>>
389 // CHECK: %[[T17:.*]] = "llvm.intr.fmuladd"(%[[T14]], %[[B]], %[[T16]]) : (vector<3xf32>, vector<3xf32>, vector<3xf32>) -> vector<3xf32>
390 // CHECK: %[[T18:.*]] = llvm.insertvalue %[[T17]], %[[T11]][1] : !llvm.array<2 x vector<3xf32>>
391 // CHECK: %[[T19:.*]] = builtin.unrealized_conversion_cast %[[T18]] : !llvm.array<2 x vector<3xf32>> to vector<2x3xf32>
392 // CHECK: return %[[T19]] : vector<2x3xf32>
394 // -----
396 func @shuffle_1D_direct(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<2xf32> {
397 %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xf32>
398 return %1 : vector<2xf32>
399 }
400 // CHECK-LABEL: @shuffle_1D_direct(
401 // CHECK-SAME: %[[A:.*]]: vector<2xf32>,
402 // CHECK-SAME: %[[B:.*]]: vector<2xf32>)
403 // CHECK: %[[s:.*]] = llvm.shufflevector %[[A]], %[[B]] [0, 1] : vector<2xf32>, vector<2xf32>
404 // CHECK: return %[[s]] : vector<2xf32>
406 // -----
408 func @shuffle_1D_index_direct(%arg0: vector<2xindex>, %arg1: vector<2xindex>) -> vector<2xindex> {
409 %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xindex>, vector<2xindex>
410 return %1 : vector<2xindex>
411 }
412 // CHECK-LABEL: @shuffle_1D_index_direct(
413 // CHECK-SAME: %[[A:.*]]: vector<2xindex>,
414 // CHECK-SAME: %[[B:.*]]: vector<2xindex>)
415 // CHECK-DAG: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2xindex> to vector<2xi64>
416 // CHECK-DAG: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2xindex> to vector<2xi64>
417 // CHECK: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T1]] [0, 1] : vector<2xi64>, vector<2xi64>
418 // CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex>
419 // CHECK: return %[[T3]] : vector<2xindex>
421 // -----
423 func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> {
424 %1 = vector.shuffle %arg0, %arg1 [4, 3, 2, 1, 0] : vector<2xf32>, vector<3xf32>
425 return %1 : vector<5xf32>
426 }
427 // CHECK-LABEL: @shuffle_1D(
428 // CHECK-SAME: %[[A:.*]]: vector<2xf32>,
429 // CHECK-SAME: %[[B:.*]]: vector<3xf32>)
430 // CHECK: %[[u0:.*]] = llvm.mlir.undef : vector<5xf32>
431 // CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : i64
432 // CHECK: %[[e1:.*]] = llvm.extractelement %[[B]][%[[c2]] : i64] : vector<3xf32>
433 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
434 // CHECK: %[[i1:.*]] = llvm.insertelement %[[e1]], %[[u0]][%[[c0]] : i64] : vector<5xf32>
435 // CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
436 // CHECK: %[[e2:.*]] = llvm.extractelement %[[B]][%[[c1]] : i64] : vector<3xf32>
437 // CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
438 // CHECK: %[[i2:.*]] = llvm.insertelement %[[e2]], %[[i1]][%[[c1]] : i64] : vector<5xf32>
439 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
440 // CHECK: %[[e3:.*]] = llvm.extractelement %[[B]][%[[c0]] : i64] : vector<3xf32>
441 // CHECK: %[[c2:.*]] = llvm.mlir.constant(2 : index) : i64
442 // CHECK: %[[i3:.*]] = llvm.insertelement %[[e3]], %[[i2]][%[[c2]] : i64] : vector<5xf32>
443 // CHECK: %[[c1:.*]] = llvm.mlir.constant(1 : index) : i64
444 // CHECK: %[[e4:.*]] = llvm.extractelement %[[A]][%[[c1]] : i64] : vector<2xf32>
445 // CHECK: %[[c3:.*]] = llvm.mlir.constant(3 : index) : i64
446 // CHECK: %[[i4:.*]] = llvm.insertelement %[[e4]], %[[i3]][%[[c3]] : i64] : vector<5xf32>
447 // CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : index) : i64
448 // CHECK: %[[e5:.*]] = llvm.extractelement %[[A]][%[[c0]] : i64] : vector<2xf32>
449 // CHECK: %[[c4:.*]] = llvm.mlir.constant(4 : index) : i64
450 // CHECK: %[[i5:.*]] = llvm.insertelement %[[e5]], %[[i4]][%[[c4]] : i64] : vector<5xf32>
451 // CHECK: return %[[i5]] : vector<5xf32>
453 // -----
455 func @shuffle_2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> {
456 %1 = vector.shuffle %a, %b[1, 0, 2] : vector<1x4xf32>, vector<2x4xf32>
457 return %1 : vector<3x4xf32>
458 }
459 // CHECK-LABEL: @shuffle_2D(
460 // CHECK-SAME: %[[A:.*]]: vector<1x4xf32>,
461 // CHECK-SAME: %[[B:.*]]: vector<2x4xf32>)
462 // CHECK-DAG: %[[VAL_0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<1x4xf32> to !llvm.array<1 x vector<4xf32>>
463 // CHECK-DAG: %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>>
464 // CHECK: %[[u0:.*]] = llvm.mlir.undef : !llvm.array<3 x vector<4xf32>>
465 // CHECK: %[[e1:.*]] = llvm.extractvalue %[[VAL_1]][0] : !llvm.array<2 x vector<4xf32>>
466 // CHECK: %[[i1:.*]] = llvm.insertvalue %[[e1]], %[[u0]][0] : !llvm.array<3 x vector<4xf32>>
467 // CHECK: %[[e2:.*]] = llvm.extractvalue %[[VAL_0]][0] : !llvm.array<1 x vector<4xf32>>
468 // CHECK: %[[i2:.*]] = llvm.insertvalue %[[e2]], %[[i1]][1] : !llvm.array<3 x vector<4xf32>>
469 // CHECK: %[[e3:.*]] = llvm.extractvalue %[[VAL_1]][1] : !llvm.array<2 x vector<4xf32>>
470 // CHECK: %[[i3:.*]] = llvm.insertvalue %[[e3]], %[[i2]][2] : !llvm.array<3 x vector<4xf32>>
471 // CHECK: %[[VAL_3:.*]] = builtin.unrealized_conversion_cast %[[i3]] : !llvm.array<3 x vector<4xf32>> to vector<3x4xf32>
472 // CHECK: return %[[VAL_3]] : vector<3x4xf32>
474 // -----
476 // CHECK-LABEL: @extract_element_0d
477 func @extract_element_0d(%a: vector<f32>) -> f32 {
478 // CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64
479 // CHECK: llvm.extractelement %{{.*}}[%[[C0]] : {{.*}}] : vector<1xf32>
480 %1 = vector.extractelement %a[] : vector<f32>
481 return %1 : f32
482 }
484 // -----
486 func @extract_element(%arg0: vector<16xf32>) -> f32 {
487 %0 = arith.constant 15 : i32
488 %1 = vector.extractelement %arg0[%0 : i32]: vector<16xf32>
489 return %1 : f32
490 }
491 // CHECK-LABEL: @extract_element(
492 // CHECK-SAME: %[[A:.*]]: vector<16xf32>)
493 // CHECK: %[[c:.*]] = arith.constant 15 : i32
494 // CHECK: %[[x:.*]] = llvm.extractelement %[[A]][%[[c]] : i32] : vector<16xf32>
495 // CHECK: return %[[x]] : f32
497 // -----
499 func @extract_element_index(%arg0: vector<16xf32>) -> f32 {
500 %0 = arith.constant 15 : index
501 %1 = vector.extractelement %arg0[%0 : index]: vector<16xf32>
502 return %1 : f32
503 }
504 // CHECK-LABEL: @extract_element_index(
505 // CHECK-SAME: %[[A:.*]]: vector<16xf32>)
506 // CHECK: %[[c:.*]] = arith.constant 15 : index
507 // CHECK: %[[i:.*]] = builtin.unrealized_conversion_cast %[[c]] : index to i64
508 // CHECK: %[[x:.*]] = llvm.extractelement %[[A]][%[[i]] : i64] : vector<16xf32>
509 // CHECK: return %[[x]] : f32
511 // -----
513 func @extract_element_from_vec_1d(%arg0: vector<16xf32>) -> f32 {
514 %0 = vector.extract %arg0[15]: vector<16xf32>
515 return %0 : f32
516 }
517 // CHECK-LABEL: @extract_element_from_vec_1d
518 // CHECK: llvm.mlir.constant(15 : i64) : i64
519 // CHECK: llvm.extractelement {{.*}}[{{.*}} : i64] : vector<16xf32>
520 // CHECK: return {{.*}} : f32
522 // -----
524 func @extract_index_element_from_vec_1d(%arg0: vector<16xindex>) -> index {
525 %0 = vector.extract %arg0[15]: vector<16xindex>
526 return %0 : index
527 }
528 // CHECK-LABEL: @extract_index_element_from_vec_1d(
529 // CHECK-SAME: %[[A:.*]]: vector<16xindex>)
530 // CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64>
531 // CHECK: %[[T1:.*]] = llvm.mlir.constant(15 : i64) : i64
532 // CHECK: %[[T2:.*]] = llvm.extractelement %[[T0]][%[[T1]] : i64] : vector<16xi64>
533 // CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : i64 to index
534 // CHECK: return %[[T3]] : index
536 // -----
538 func @extract_vec_2d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<3x16xf32> {
539 %0 = vector.extract %arg0[0]: vector<4x3x16xf32>
540 return %0 : vector<3x16xf32>
541 }
542 // CHECK-LABEL: @extract_vec_2d_from_vec_3d
543 // CHECK: llvm.extractvalue {{.*}}[0] : !llvm.array<4 x array<3 x vector<16xf32>>>
544 // CHECK: return {{.*}} : vector<3x16xf32>
546 // -----
548 func @extract_vec_1d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<16xf32> {
549 %0 = vector.extract %arg0[0, 0]: vector<4x3x16xf32>
550 return %0 : vector<16xf32>
551 }
552 // CHECK-LABEL: @extract_vec_1d_from_vec_3d
553 // CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vector<16xf32>>>
554 // CHECK: return {{.*}} : vector<16xf32>
556 // -----
558 func @extract_element_from_vec_3d(%arg0: vector<4x3x16xf32>) -> f32 {
559 %0 = vector.extract %arg0[0, 0, 0]: vector<4x3x16xf32>
560 return %0 : f32
561 }
562 // CHECK-LABEL: @extract_element_from_vec_3d
563 // CHECK: llvm.extractvalue {{.*}}[0, 0] : !llvm.array<4 x array<3 x vector<16xf32>>>
564 // CHECK: llvm.mlir.constant(0 : i64) : i64
565 // CHECK: llvm.extractelement {{.*}}[{{.*}} : i64] : vector<16xf32>
566 // CHECK: return {{.*}} : f32
568 // -----
570 // CHECK-LABEL: @insert_element_0d
571 // CHECK-SAME: %[[A:.*]]: f32,
572 func @insert_element_0d(%a: f32, %b: vector<f32>) -> vector<f32> {
573 // CHECK: %[[B:.*]] = builtin.unrealized_conversion_cast %{{.*}} :
574 // CHECK: vector<f32> to vector<1xf32>
575 // CHECK: %[[C0:.*]] = llvm.mlir.constant(0 : index) : i64
576 // CHECK: %[[x:.*]] = llvm.insertelement %[[A]], %[[B]][%[[C0]] : {{.*}}] : vector<1xf32>
577 %1 = vector.insertelement %a, %b[] : vector<f32>
578 return %1 : vector<f32>
579 }
581 // -----
583 func @insert_element(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
584 %0 = arith.constant 3 : i32
585 %1 = vector.insertelement %arg0, %arg1[%0 : i32] : vector<4xf32>
586 return %1 : vector<4xf32>
587 }
588 // CHECK-LABEL: @insert_element(
589 // CHECK-SAME: %[[A:.*]]: f32,
590 // CHECK-SAME: %[[B:.*]]: vector<4xf32>)
591 // CHECK: %[[c:.*]] = arith.constant 3 : i32
592 // CHECK: %[[x:.*]] = llvm.insertelement %[[A]], %[[B]][%[[c]] : i32] : vector<4xf32>
593 // CHECK: return %[[x]] : vector<4xf32>
595 // -----
597 func @insert_element_index(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
598 %0 = arith.constant 3 : index
599 %1 = vector.insertelement %arg0, %arg1[%0 : index] : vector<4xf32>
600 return %1 : vector<4xf32>
601 }
602 // CHECK-LABEL: @insert_element_index(
603 // CHECK-SAME: %[[A:.*]]: f32,
604 // CHECK-SAME: %[[B:.*]]: vector<4xf32>)
605 // CHECK: %[[c:.*]] = arith.constant 3 : index
606 // CHECK: %[[i:.*]] = builtin.unrealized_conversion_cast %[[c]] : index to i64
607 // CHECK: %[[x:.*]] = llvm.insertelement %[[A]], %[[B]][%[[i]] : i64] : vector<4xf32>
608 // CHECK: return %[[x]] : vector<4xf32>
610 // -----
612 func @insert_element_into_vec_1d(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
613 %0 = vector.insert %arg0, %arg1[3] : f32 into vector<4xf32>
614 return %0 : vector<4xf32>
615 }
616 // CHECK-LABEL: @insert_element_into_vec_1d
617 // CHECK: llvm.mlir.constant(3 : i64) : i64
618 // CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<4xf32>
619 // CHECK: return {{.*}} : vector<4xf32>
621 // -----
623 func @insert_index_element_into_vec_1d(%arg0: index, %arg1: vector<4xindex>) -> vector<4xindex> {
624 %0 = vector.insert %arg0, %arg1[3] : index into vector<4xindex>
625 return %0 : vector<4xindex>
626 }
627 // CHECK-LABEL: @insert_index_element_into_vec_1d(
628 // CHECK-SAME: %[[A:.*]]: index,
629 // CHECK-SAME: %[[B:.*]]: vector<4xindex>)
630 // CHECK-DAG: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64
631 // CHECK-DAG: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<4xindex> to vector<4xi64>
632 // CHECK: %[[T3:.*]] = llvm.mlir.constant(3 : i64) : i64
633 // CHECK: %[[T4:.*]] = llvm.insertelement %[[T0]], %[[T1]][%[[T3]] : i64] : vector<4xi64>
634 // CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : vector<4xi64> to vector<4xindex>
635 // CHECK: return %[[T5]] : vector<4xindex>
637 // -----
639 func @insert_vec_2d_into_vec_3d(%arg0: vector<8x16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
640 %0 = vector.insert %arg0, %arg1[3] : vector<8x16xf32> into vector<4x8x16xf32>
641 return %0 : vector<4x8x16xf32>
642 }
643 // CHECK-LABEL: @insert_vec_2d_into_vec_3d
644 // CHECK: llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm.array<4 x array<8 x vector<16xf32>>>
645 // CHECK: return {{.*}} : vector<4x8x16xf32>
647 // -----
649 func @insert_vec_1d_into_vec_3d(%arg0: vector<16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
650 %0 = vector.insert %arg0, %arg1[3, 7] : vector<16xf32> into vector<4x8x16xf32>
651 return %0 : vector<4x8x16xf32>
652 }
653 // CHECK-LABEL: @insert_vec_1d_into_vec_3d
654 // CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>>
655 // CHECK: return {{.*}} : vector<4x8x16xf32>
657 // -----
659 func @insert_element_into_vec_3d(%arg0: f32, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
660 %0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x16xf32>
661 return %0 : vector<4x8x16xf32>
662 }
663 // CHECK-LABEL: @insert_element_into_vec_3d
664 // CHECK: llvm.extractvalue {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>>
665 // CHECK: llvm.mlir.constant(15 : i64) : i64
666 // CHECK: llvm.insertelement {{.*}}, {{.*}}[{{.*}} : i64] : vector<16xf32>
667 // CHECK: llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm.array<4 x array<8 x vector<16xf32>>>
668 // CHECK: return {{.*}} : vector<4x8x16xf32>
670 // -----
672 func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> {
673 %0 = vector.type_cast %arg0: memref<8x8x8xf32> to memref<vector<8x8x8xf32>>
674 return %0 : memref<vector<8x8x8xf32>>
675 }
676 // CHECK-LABEL: @vector_type_cast
677 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>>, ptr<array<8 x array<8 x vector<8xf32>>>>, i64)>
678 // CHECK: %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
679 // CHECK: %[[allocatedBit:.*]] = llvm.bitcast %[[allocated]] : !llvm.ptr<f32> to !llvm.ptr<array<8 x array<8 x vector<8xf32>>>>
680 // CHECK: llvm.insertvalue %[[allocatedBit]], {{.*}}[0] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>>, ptr<array<8 x array<8 x vector<8xf32>>>>, i64)>
681 // CHECK: %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<3 x i64>, array<3 x i64>)>
682 // CHECK: %[[alignedBit:.*]] = llvm.bitcast %[[aligned]] : !llvm.ptr<f32> to !llvm.ptr<array<8 x array<8 x vector<8xf32>>>>
683 // CHECK: llvm.insertvalue %[[alignedBit]], {{.*}}[1] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>>, ptr<array<8 x array<8 x vector<8xf32>>>>, i64)>
684 // CHECK: llvm.mlir.constant(0 : index
685 // CHECK: llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>>, ptr<array<8 x array<8 x vector<8xf32>>>>, i64)>
687 // -----
689 func @vector_index_type_cast(%arg0: memref<8x8x8xindex>) -> memref<vector<8x8x8xindex>> {
690 %0 = vector.type_cast %arg0: memref<8x8x8xindex> to memref<vector<8x8x8xindex>>
691 return %0 : memref<vector<8x8x8xindex>>
692 }
693 // CHECK-LABEL: @vector_index_type_cast(
694 // CHECK-SAME: %[[A:.*]]: memref<8x8x8xindex>)
695 // CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[A]] : memref<8x8x8xindex> to !llvm.struct<(ptr<i64>, ptr<i64>, i64, array<3 x i64>, array<3 x i64>)>
697 // CHECK: %{{.*}} = builtin.unrealized_conversion_cast %{{.*}} : !llvm.struct<(ptr<array<8 x array<8 x vector<8xi64>>>>, ptr<array<8 x array<8 x vector<8xi64>>>>, i64)> to memref<vector<8x8x8xindex>>
699 // -----
701 func @vector_type_cast_non_zero_addrspace(%arg0: memref<8x8x8xf32, 3>) -> memref<vector<8x8x8xf32>, 3> {
702 %0 = vector.type_cast %arg0: memref<8x8x8xf32, 3> to memref<vector<8x8x8xf32>, 3>
703 return %0 : memref<vector<8x8x8xf32>, 3>
704 }
705 // CHECK-LABEL: @vector_type_cast_non_zero_addrspace
706 // CHECK: llvm.mlir.undef : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>, 3>, ptr<array<8 x array<8 x vector<8xf32>>>, 3>, i64)>
707 // CHECK: %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.struct<(ptr<f32, 3>, ptr<f32, 3>, i64, array<3 x i64>, array<3 x i64>)>
708 // CHECK: %[[allocatedBit:.*]] = llvm.bitcast %[[allocated]] : !llvm.ptr<f32, 3> to !llvm.ptr<array<8 x array<8 x vector<8xf32>>>, 3>
709 // CHECK: llvm.insertvalue %[[allocatedBit]], {{.*}}[0] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>, 3>, ptr<array<8 x array<8 x vector<8xf32>>>, 3>, i64)>
710 // CHECK: %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm.struct<(ptr<f32, 3>, ptr<f32, 3>, i64, array<3 x i64>, array<3 x i64>)>
711 // CHECK: %[[alignedBit:.*]] = llvm.bitcast %[[aligned]] : !llvm.ptr<f32, 3> to !llvm.ptr<array<8 x array<8 x vector<8xf32>>>, 3>
712 // CHECK: llvm.insertvalue %[[alignedBit]], {{.*}}[1] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>, 3>, ptr<array<8 x array<8 x vector<8xf32>>>, 3>, i64)>
713 // CHECK: llvm.mlir.constant(0 : index
714 // CHECK: llvm.insertvalue {{.*}}[2] : !llvm.struct<(ptr<array<8 x array<8 x vector<8xf32>>>, 3>, ptr<array<8 x array<8 x vector<8xf32>>>, 3>, i64)>
716 // -----
718 func @vector_print_scalar_i1(%arg0: i1) {
719 vector.print %arg0 : i1
720 return
721 }
722 //
723 // Type "boolean" always uses zero extension.
724 //
725 // CHECK-LABEL: @vector_print_scalar_i1(
726 // CHECK-SAME: %[[A:.*]]: i1)
727 // CHECK: %[[S:.*]] = arith.extui %[[A]] : i1 to i64
728 // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
729 // CHECK: llvm.call @printNewline() : () -> ()
731 // -----
733 func @vector_print_scalar_i4(%arg0: i4) {
734 vector.print %arg0 : i4
735 return
736 }
737 // CHECK-LABEL: @vector_print_scalar_i4(
738 // CHECK-SAME: %[[A:.*]]: i4)
739 // CHECK: %[[S:.*]] = arith.extsi %[[A]] : i4 to i64
740 // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
741 // CHECK: llvm.call @printNewline() : () -> ()
743 // -----
745 func @vector_print_scalar_si4(%arg0: si4) {
746 vector.print %arg0 : si4
747 return
748 }
749 // CHECK-LABEL: @vector_print_scalar_si4(
750 // CHECK-SAME: %[[A:.*]]: si4)
751 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : si4 to i4
752 // CHECK: %[[S:.*]] = arith.extsi %[[C]] : i4 to i64
753 // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
754 // CHECK: llvm.call @printNewline() : () -> ()
756 // -----
758 func @vector_print_scalar_ui4(%arg0: ui4) {
759 vector.print %arg0 : ui4
760 return
761 }
762 // CHECK-LABEL: @vector_print_scalar_ui4(
763 // CHECK-SAME: %[[A:.*]]: ui4)
764 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui4 to i4
765 // CHECK: %[[S:.*]] = arith.extui %[[C]] : i4 to i64
766 // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> ()
767 // CHECK: llvm.call @printNewline() : () -> ()
769 // -----
771 func @vector_print_scalar_i32(%arg0: i32) {
772 vector.print %arg0 : i32
773 return
774 }
775 // CHECK-LABEL: @vector_print_scalar_i32(
776 // CHECK-SAME: %[[A:.*]]: i32)
777 // CHECK: %[[S:.*]] = arith.extsi %[[A]] : i32 to i64
778 // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
779 // CHECK: llvm.call @printNewline() : () -> ()
781 // -----
783 func @vector_print_scalar_ui32(%arg0: ui32) {
784 vector.print %arg0 : ui32
785 return
786 }
787 // CHECK-LABEL: @vector_print_scalar_ui32(
788 // CHECK-SAME: %[[A:.*]]: ui32)
789 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui32 to i32
790 // CHECK: %[[S:.*]] = arith.extui %[[C]] : i32 to i64
791 // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> ()
793 // -----
795 func @vector_print_scalar_i40(%arg0: i40) {
796 vector.print %arg0 : i40
797 return
798 }
799 // CHECK-LABEL: @vector_print_scalar_i40(
800 // CHECK-SAME: %[[A:.*]]: i40)
801 // CHECK: %[[S:.*]] = arith.extsi %[[A]] : i40 to i64
802 // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
803 // CHECK: llvm.call @printNewline() : () -> ()
805 // -----
807 func @vector_print_scalar_si40(%arg0: si40) {
808 vector.print %arg0 : si40
809 return
810 }
811 // CHECK-LABEL: @vector_print_scalar_si40(
812 // CHECK-SAME: %[[A:.*]]: si40)
813 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : si40 to i40
814 // CHECK: %[[S:.*]] = arith.extsi %[[C]] : i40 to i64
815 // CHECK: llvm.call @printI64(%[[S]]) : (i64) -> ()
816 // CHECK: llvm.call @printNewline() : () -> ()
818 // -----
820 func @vector_print_scalar_ui40(%arg0: ui40) {
821 vector.print %arg0 : ui40
822 return
823 }
824 // CHECK-LABEL: @vector_print_scalar_ui40(
825 // CHECK-SAME: %[[A:.*]]: ui40)
826 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui40 to i40
827 // CHECK: %[[S:.*]] = arith.extui %[[C]] : i40 to i64
828 // CHECK: llvm.call @printU64(%[[S]]) : (i64) -> ()
829 // CHECK: llvm.call @printNewline() : () -> ()
831 // -----
833 func @vector_print_scalar_i64(%arg0: i64) {
834 vector.print %arg0 : i64
835 return
836 }
837 // CHECK-LABEL: @vector_print_scalar_i64(
838 // CHECK-SAME: %[[A:.*]]: i64)
839 // CHECK: llvm.call @printI64(%[[A]]) : (i64) -> ()
840 // CHECK: llvm.call @printNewline() : () -> ()
842 // -----
844 func @vector_print_scalar_ui64(%arg0: ui64) {
845 vector.print %arg0 : ui64
846 return
847 }
848 // CHECK-LABEL: @vector_print_scalar_ui64(
849 // CHECK-SAME: %[[A:.*]]: ui64)
850 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : ui64 to i64
851 // CHECK: llvm.call @printU64(%[[C]]) : (i64) -> ()
852 // CHECK: llvm.call @printNewline() : () -> ()
854 // -----
856 func @vector_print_scalar_index(%arg0: index) {
857 vector.print %arg0 : index
858 return
859 }
860 // CHECK-LABEL: @vector_print_scalar_index(
861 // CHECK-SAME: %[[A:.*]]: index)
862 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[A]] : index to i64
863 // CHECK: llvm.call @printU64(%[[C]]) : (i64) -> ()
864 // CHECK: llvm.call @printNewline() : () -> ()
866 // -----
868 func @vector_print_scalar_f32(%arg0: f32) {
869 vector.print %arg0 : f32
870 return
871 }
872 // CHECK-LABEL: @vector_print_scalar_f32(
873 // CHECK-SAME: %[[A:.*]]: f32)
874 // CHECK: llvm.call @printF32(%[[A]]) : (f32) -> ()
875 // CHECK: llvm.call @printNewline() : () -> ()
877 // -----
879 func @vector_print_scalar_f64(%arg0: f64) {
880 vector.print %arg0 : f64
881 return
882 }
883 // CHECK-LABEL: @vector_print_scalar_f64(
884 // CHECK-SAME: %[[A:.*]]: f64)
885 // CHECK: llvm.call @printF64(%[[A]]) : (f64) -> ()
886 // CHECK: llvm.call @printNewline() : () -> ()
888 // -----
890 func @vector_print_vector_0d(%arg0: vector<f32>) {
891 vector.print %arg0 : vector<f32>
892 return
893 }
894 // CHECK-LABEL: @vector_print_vector_0d(
895 // CHECK-SAME: %[[A:.*]]: vector<f32>)
896 // CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<f32> to vector<1xf32>
897 // CHECK: llvm.call @printOpen() : () -> ()
898 // CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : index) : i64
899 // CHECK: %[[T2:.*]] = llvm.extractelement %[[T0]][%[[T1]] : i64] : vector<1xf32>
900 // CHECK: llvm.call @printF32(%[[T2]]) : (f32) -> ()
901 // CHECK: llvm.call @printClose() : () -> ()
902 // CHECK: llvm.call @printNewline() : () -> ()
903 // CHECK: return
905 // -----
907 func @vector_print_vector(%arg0: vector<2x2xf32>) {
908 vector.print %arg0 : vector<2x2xf32>
909 return
910 }
911 // CHECK-LABEL: @vector_print_vector(
912 // CHECK-SAME: %[[A:.*]]: vector<2x2xf32>)
913 // CHECK: %[[VAL_1:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>>
914 // CHECK: llvm.call @printOpen() : () -> ()
915 // CHECK: %[[x0:.*]] = llvm.extractvalue %[[VAL_1]][0] : !llvm.array<2 x vector<2xf32>>
916 // CHECK: llvm.call @printOpen() : () -> ()
917 // CHECK: %[[x1:.*]] = llvm.mlir.constant(0 : index) : i64
918 // CHECK: %[[x2:.*]] = llvm.extractelement %[[x0]][%[[x1]] : i64] : vector<2xf32>
919 // CHECK: llvm.call @printF32(%[[x2]]) : (f32) -> ()
920 // CHECK: llvm.call @printComma() : () -> ()
921 // CHECK: %[[x3:.*]] = llvm.mlir.constant(1 : index) : i64
922 // CHECK: %[[x4:.*]] = llvm.extractelement %[[x0]][%[[x3]] : i64] : vector<2xf32>
923 // CHECK: llvm.call @printF32(%[[x4]]) : (f32) -> ()
924 // CHECK: llvm.call @printClose() : () -> ()
925 // CHECK: llvm.call @printComma() : () -> ()
926 // CHECK: %[[x5:.*]] = llvm.extractvalue %[[VAL_1]][1] : !llvm.array<2 x vector<2xf32>>
927 // CHECK: llvm.call @printOpen() : () -> ()
928 // CHECK: %[[x6:.*]] = llvm.mlir.constant(0 : index) : i64
929 // CHECK: %[[x7:.*]] = llvm.extractelement %[[x5]][%[[x6]] : i64] : vector<2xf32>
930 // CHECK: llvm.call @printF32(%[[x7]]) : (f32) -> ()
931 // CHECK: llvm.call @printComma() : () -> ()
932 // CHECK: %[[x8:.*]] = llvm.mlir.constant(1 : index) : i64
933 // CHECK: %[[x9:.*]] = llvm.extractelement %[[x5]][%[[x8]] : i64] : vector<2xf32>
934 // CHECK: llvm.call @printF32(%[[x9]]) : (f32) -> ()
935 // CHECK: llvm.call @printClose() : () -> ()
936 // CHECK: llvm.call @printClose() : () -> ()
937 // CHECK: llvm.call @printNewline() : () -> ()
939 // -----
941 func @extract_strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> {
942 %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32>
943 return %0 : vector<2xf32>
944 }
945 // CHECK-LABEL: @extract_strided_slice1(
946 // CHECK-SAME: %[[A:.*]]: vector<4xf32>)
947 // CHECK: %[[T0:.*]] = llvm.shufflevector %[[A]], %[[A]] [2, 3] : vector<4xf32>, vector<4xf32>
948 // CHECK: return %[[T0]] : vector<2xf32>
950 // -----
952 func @extract_strided_index_slice1(%arg0: vector<4xindex>) -> vector<2xindex> {
953 %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xindex> to vector<2xindex>
954 return %0 : vector<2xindex>
955 }
956 // CHECK-LABEL: @extract_strided_index_slice1(
957 // CHECK-SAME: %[[A:.*]]: vector<4xindex>)
958 // CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<4xindex> to vector<4xi64>
959 // CHECK: %[[T2:.*]] = llvm.shufflevector %[[T0]], %[[T0]] [2, 3] : vector<4xi64>, vector<4xi64>
960 // CHECK: %[[T3:.*]] = builtin.unrealized_conversion_cast %[[T2]] : vector<2xi64> to vector<2xindex>
961 // CHECK: return %[[T3]] : vector<2xindex>
963 // -----
965 func @extract_strided_slice2(%arg0: vector<4x8xf32>) -> vector<2x8xf32> {
966 %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8xf32> to vector<2x8xf32>
967 return %0 : vector<2x8xf32>
968 }
969 // CHECK-LABEL: @extract_strided_slice2(
970 // CHECK-SAME: %[[ARG:.*]]: vector<4x8xf32>)
971 // CHECK: %[[A:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>>
972 // CHECK: %[[T0:.*]] = llvm.mlir.undef : !llvm.array<2 x vector<8xf32>>
973 // CHECK: %[[T1:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vector<8xf32>>
974 // CHECK: %[[T2:.*]] = llvm.insertvalue %[[T1]], %[[T0]][0] : !llvm.array<2 x vector<8xf32>>
975 // CHECK: %[[T3:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vector<8xf32>>
976 // CHECK: %[[T4:.*]] = llvm.insertvalue %[[T3]], %[[T2]][1] : !llvm.array<2 x vector<8xf32>>
977 // CHECK: %[[T5:.*]] = builtin.unrealized_conversion_cast %[[T4]] : !llvm.array<2 x vector<8xf32>> to vector<2x8xf32>
978 // CHECK: return %[[T5]]
980 // -----
982 func @extract_strided_slice3(%arg0: vector<4x8xf32>) -> vector<2x2xf32> {
983 %0 = vector.extract_strided_slice %arg0 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8xf32> to vector<2x2xf32>
984 return %0 : vector<2x2xf32>
985 }
986 // CHECK-LABEL: @extract_strided_slice3(
987 // CHECK-SAME: %[[ARG:.*]]: vector<4x8xf32>)
988 // CHECK: %[[A:.*]] = builtin.unrealized_conversion_cast %[[ARG]] : vector<4x8xf32> to !llvm.array<4 x vector<8xf32>>
989 // CHECK: %[[VAL_1:.*]] = arith.constant 0.000000e+00 : f32
990 // CHECK: %[[VAL_2:.*]] = splat %[[VAL_1]] : vector<2x2xf32>
991 // CHECK: %[[VAL_6:.*]] = builtin.unrealized_conversion_cast %[[VAL_2]] : vector<2x2xf32> to !llvm.array<2 x vector<2xf32>>
992 // CHECK: %[[T2:.*]] = llvm.extractvalue %[[A]][2] : !llvm.array<4 x vector<8xf32>>
993 // CHECK: %[[T3:.*]] = llvm.shufflevector %[[T2]], %[[T2]] [2, 3] : vector<8xf32>, vector<8xf32>
994 // CHECK: %[[T4:.*]] = llvm.insertvalue %[[T3]], %[[VAL_6]][0] : !llvm.array<2 x vector<2xf32>>
995 // CHECK: %[[T5:.*]] = llvm.extractvalue %[[A]][3] : !llvm.array<4 x vector<8xf32>>
996 // CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T5]] [2, 3] : vector<8xf32>, vector<8xf32>
997 // CHECK: %[[T7:.*]] = llvm.insertvalue %[[T6]], %[[T4]][1] : !llvm.array<2 x vector<2xf32>>
998 // CHECK: %[[VAL_12:.*]] = builtin.unrealized_conversion_cast %[[T7]] : !llvm.array<2 x vector<2xf32>> to vector<2x2xf32>
999 // CHECK: return %[[VAL_12]] : vector<2x2xf32>
1001 // -----
1003 func @insert_strided_slice1(%b: vector<4x4xf32>, %c: vector<4x4x4xf32>) -> vector<4x4x4xf32> {
1004 %0 = vector.insert_strided_slice %b, %c {offsets = [2, 0, 0], strides = [1, 1]} : vector<4x4xf32> into vector<4x4x4xf32>
1005 return %0 : vector<4x4x4xf32>
1006 }
1007 // CHECK-LABEL: @insert_strided_slice1
1008 // CHECK: llvm.extractvalue {{.*}}[2] : !llvm.array<4 x array<4 x vector<4xf32>>>
1009 // CHECK: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm.array<4 x array<4 x vector<4xf32>>>
1011 // -----
1013 func @insert_strided_index_slice1(%b: vector<4x4xindex>, %c: vector<4x4x4xindex>) -> vector<4x4x4xindex> {
1014 %0 = vector.insert_strided_slice %b, %c {offsets = [2, 0, 0], strides = [1, 1]} : vector<4x4xindex> into vector<4x4x4xindex>
1015 return %0 : vector<4x4x4xindex>
1016 }
1017 // CHECK-LABEL: @insert_strided_index_slice1(
1018 // CHECK: llvm.extractvalue {{.*}}[2] : !llvm.array<4 x array<4 x vector<4xi64>>>
1019 // CHECK: llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm.array<4 x array<4 x vector<4xi64>>>
1021 // -----
1023 func @insert_strided_slice2(%a: vector<2x2xf32>, %b: vector<4x4xf32>) -> vector<4x4xf32> {
1024 %0 = vector.insert_strided_slice %a, %b {offsets = [2, 2], strides = [1, 1]} : vector<2x2xf32> into vector<4x4xf32>
1025 return %0 : vector<4x4xf32>
1026 }
1028 // CHECK-LABEL: @insert_strided_slice2
1029 //
1030 // Subvector vector<2xf32> @0 into vector<4xf32> @2
1031 // CHECK: %[[V2_0:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.array<2 x vector<2xf32>>
1032 // CHECK: %[[V4_0:.*]] = llvm.extractvalue {{.*}}[2] : !llvm.array<4 x vector<4xf32>>
1033 // Element @0 -> element @2
1034 // CHECK: %[[R4_0:.*]] = llvm.shufflevector %[[V2_0]], %[[V2_0]] [0, 1, 0, 0] : vector<2xf32>, vector<2xf32>
1035 // CHECK: %[[R4_1:.*]] = llvm.shufflevector %[[R4_0]], %[[V4_0]] [4, 5, 0, 1] : vector<4xf32>, vector<4xf32>
1036 // CHECK: llvm.insertvalue %[[R4_1]], {{.*}}[2] : !llvm.array<4 x vector<4xf32>>
1037 //
1038 // Subvector vector<2xf32> @1 into vector<4xf32> @3
1039 // CHECK: %[[V2_1:.*]] = llvm.extractvalue {{.*}}[1] : !llvm.array<2 x vector<2xf32>>
1040 // CHECK: %[[V4_3:.*]] = llvm.extractvalue {{.*}}[3] : !llvm.array<4 x vector<4xf32>>
1041 // Element @0 -> element @2
1042 // CHECK: %[[R4_2:.*]] = llvm.shufflevector %[[V2_1]], %[[V2_1]] [0, 1, 0, 0] : vector<2xf32>, vector<2xf32>
1043 // CHECK: %[[R4_3:.*]] = llvm.shufflevector %[[R4_2]], %[[V4_3]] [4, 5, 0, 1] : vector<4xf32>, vector<4xf32>
1044 // CHECK: llvm.insertvalue %[[R4_3]], {{.*}}[3] : !llvm.array<4 x vector<4xf32>>
1046 // -----
1048 func @insert_strided_slice3(%arg0: vector<2x4xf32>, %arg1: vector<16x4x8xf32>) -> vector<16x4x8xf32> {
1049 %0 = vector.insert_strided_slice %arg0, %arg1 {offsets = [0, 0, 2], strides = [1, 1]}:
1050 vector<2x4xf32> into vector<16x4x8xf32>
1051 return %0 : vector<16x4x8xf32>
1052 }
1053 // CHECK-LABEL: func @insert_strided_slice3
1054 // CHECK: %[[V4_0:.*]] = llvm.extractvalue {{.*}}[0] : !llvm.array<2 x vector<4xf32>>
1055 // CHECK: %[[V4_0_0:.*]] = llvm.extractvalue {{.*}}[0, 0] : !llvm.array<16 x array<4 x vector<8xf32>>>
1056 // CHECK: %[[R8_0:.*]] = llvm.shufflevector %[[V4_0]], %[[V4_0]] [0, 1, 2, 3, 0, 0, 0, 0] : vector<4xf32>, vector<4xf32>
1057 // CHECK: %[[R8_1:.*]] = llvm.shufflevector %[[R8_0:.*]], %[[V4_0_0]] [8, 9, 0, 1, 2, 3, 14, 15] : vector<8xf32>, vector<8xf32>
1058 // CHECK: llvm.insertvalue %[[R8_1]], {{.*}}[0] : !llvm.array<4 x vector<8xf32>>
1060 // CHECK: %[[V4_1:.*]] = llvm.extractvalue {{.*}}[1] : !llvm.array<2 x vector<4xf32>>
1061 // CHECK: %[[V4_0_1:.*]] = llvm.extractvalue {{.*}}[0, 1] : !llvm.array<16 x array<4 x vector<8xf32>>>
1062 // CHECK: %[[R8_2:.*]] = llvm.shufflevector %[[V4_1]], %[[V4_1]] [0, 1, 2, 3, 0, 0, 0, 0] : vector<4xf32>, vector<4xf32>
1063 // CHECK: %[[R8_3:.*]] = llvm.shufflevector %[[R8_2]], %[[V4_0_1]] [8, 9, 0, 1, 2, 3, 14, 15] : vector<8xf32>, vector<8xf32>
1064 // CHECK: llvm.insertvalue %[[R8_3]], {{.*}}[1] : !llvm.array<4 x vector<8xf32>>
1066 // -----
1068 func @vector_fma(%a: vector<8xf32>, %b: vector<2x4xf32>, %c: vector<1x1x1xf32>) -> (vector<8xf32>, vector<2x4xf32>, vector<1x1x1xf32>) {
1069 // CHECK-LABEL: @vector_fma
1070 // CHECK-SAME: %[[A:.*]]: vector<8xf32>
1071 // CHECK-SAME: %[[B:.*]]: vector<2x4xf32>
1072 // CHECK-SAME: %[[C:.*]]: vector<1x1x1xf32>
1073 // CHECK: %[[BL:.*]] = builtin.unrealized_conversion_cast %[[B]] : vector<2x4xf32> to !llvm.array<2 x vector<4xf32>>
1074 // CHECK: "llvm.intr.fmuladd"
1075 // CHECK-SAME: (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32>
1076 %0 = vector.fma %a, %a, %a : vector<8xf32>
1078 // CHECK: %[[b00:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>>
1079 // CHECK: %[[b01:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>>
1080 // CHECK: %[[b02:.*]] = llvm.extractvalue %[[BL]][0] : !llvm.array<2 x vector<4xf32>>
1081 // CHECK: %[[B0:.*]] = "llvm.intr.fmuladd"(%[[b00]], %[[b01]], %[[b02]]) :
1082 // CHECK-SAME: (vector<4xf32>, vector<4xf32>, vector<4xf32>) -> vector<4xf32>
1083 // CHECK: llvm.insertvalue %[[B0]], {{.*}}[0] : !llvm.array<2 x vector<4xf32>>
1084 // CHECK: %[[b10:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>>
1085 // CHECK: %[[b11:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>>
1086 // CHECK: %[[b12:.*]] = llvm.extractvalue %[[BL]][1] : !llvm.array<2 x vector<4xf32>>
1087 // CHECK: %[[B1:.*]] = "llvm.intr.fmuladd"(%[[b10]], %[[b11]], %[[b12]]) :
1088 // CHECK-SAME: (vector<4xf32>, vector<4xf32>, vector<4xf32>) -> vector<4xf32>
1089 // CHECK: llvm.insertvalue %[[B1]], {{.*}}[1] : !llvm.array<2 x vector<4xf32>>
1090 %1 = vector.fma %b, %b, %b : vector<2x4xf32>
1092 // CHECK: %[[C0:.*]] = "llvm.intr.fmuladd"
1093 // CHECK-SAME: (vector<1xf32>, vector<1xf32>, vector<1xf32>) -> vector<1xf32>
1094 %2 = vector.fma %c, %c, %c : vector<1x1x1xf32>
1096 return %0, %1, %2: vector<8xf32>, vector<2x4xf32>, vector<1x1x1xf32>
1097 }
1099 // -----
1101 func @reduce_f16(%arg0: vector<16xf16>) -> f16 {
1102 %0 = vector.reduction "add", %arg0 : vector<16xf16> into f16
1103 return %0 : f16
1104 }
1105 // CHECK-LABEL: @reduce_f16(
1106 // CHECK-SAME: %[[A:.*]]: vector<16xf16>)
1107 // CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f16) : f16
1108 // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
1109 // CHECK-SAME: {reassoc = false} : (f16, vector<16xf16>) -> f16
1110 // CHECK: return %[[V]] : f16
1112 // -----
1114 func @reduce_f32(%arg0: vector<16xf32>) -> f32 {
1115 %0 = vector.reduction "add", %arg0 : vector<16xf32> into f32
1116 return %0 : f32
1117 }
1118 // CHECK-LABEL: @reduce_f32(
1119 // CHECK-SAME: %[[A:.*]]: vector<16xf32>)
1120 // CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : f32
1121 // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
1122 // CHECK-SAME: {reassoc = false} : (f32, vector<16xf32>) -> f32
1123 // CHECK: return %[[V]] : f32
1125 // -----
1127 func @reduce_f64(%arg0: vector<16xf64>) -> f64 {
1128 %0 = vector.reduction "add", %arg0 : vector<16xf64> into f64
1129 return %0 : f64
1130 }
1131 // CHECK-LABEL: @reduce_f64(
1132 // CHECK-SAME: %[[A:.*]]: vector<16xf64>)
1133 // CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : f64
1134 // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.fadd"(%[[C]], %[[A]])
1135 // CHECK-SAME: {reassoc = false} : (f64, vector<16xf64>) -> f64
1136 // CHECK: return %[[V]] : f64
1138 // -----
1140 func @reduce_i8(%arg0: vector<16xi8>) -> i8 {
1141 %0 = vector.reduction "add", %arg0 : vector<16xi8> into i8
1142 return %0 : i8
1143 }
1144 // CHECK-LABEL: @reduce_i8(
1145 // CHECK-SAME: %[[A:.*]]: vector<16xi8>)
1146 // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
1147 // CHECK: return %[[V]] : i8
1149 // -----
1151 func @reduce_i32(%arg0: vector<16xi32>) -> i32 {
1152 %0 = vector.reduction "add", %arg0 : vector<16xi32> into i32
1153 return %0 : i32
1154 }
1155 // CHECK-LABEL: @reduce_i32(
1156 // CHECK-SAME: %[[A:.*]]: vector<16xi32>)
1157 // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
1158 // CHECK: return %[[V]] : i32
1160 // -----
1162 func @reduce_i64(%arg0: vector<16xi64>) -> i64 {
1163 %0 = vector.reduction "add", %arg0 : vector<16xi64> into i64
1164 return %0 : i64
1165 }
1166 // CHECK-LABEL: @reduce_i64(
1167 // CHECK-SAME: %[[A:.*]]: vector<16xi64>)
1168 // CHECK: %[[V:.*]] = "llvm.intr.vector.reduce.add"(%[[A]])
1169 // CHECK: return %[[V]] : i64
1171 // -----
1173 func @reduce_index(%arg0: vector<16xindex>) -> index {
1174 %0 = vector.reduction "add", %arg0 : vector<16xindex> into index
1175 return %0 : index
1176 }
1177 // CHECK-LABEL: @reduce_index(
1178 // CHECK-SAME: %[[A:.*]]: vector<16xindex>)
1179 // CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64>
1180 // CHECK: %[[T1:.*]] = "llvm.intr.vector.reduce.add"(%[[T0]])
1181 // CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : i64 to index
1182 // CHECK: return %[[T2]] : index
1184 // 4x16 16x3 4x3
1185 // -----
1187 func @matrix_ops(%A: vector<64xf64>, %B: vector<48xf64>) -> vector<12xf64> {
1188 %C = vector.matrix_multiply %A, %B
1189 { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } :
1190 (vector<64xf64>, vector<48xf64>) -> vector<12xf64>
1191 return %C: vector<12xf64>
1192 }
1193 // CHECK-LABEL: @matrix_ops
1194 // CHECK: llvm.intr.matrix.multiply %{{.*}}, %{{.*}} {
1195 // CHECK-SAME: lhs_columns = 16 : i32, lhs_rows = 4 : i32, rhs_columns = 3 : i32
1196 // CHECK-SAME: } : (vector<64xf64>, vector<48xf64>) -> vector<12xf64>
1198 // -----
1200 func @matrix_ops_index(%A: vector<64xindex>, %B: vector<48xindex>) -> vector<12xindex> {
1201 %C = vector.matrix_multiply %A, %B
1202 { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } :
1203 (vector<64xindex>, vector<48xindex>) -> vector<12xindex>
1204 return %C: vector<12xindex>
1205 }
1206 // CHECK-LABEL: @matrix_ops_index
1207 // CHECK: llvm.intr.matrix.multiply %{{.*}}, %{{.*}} {
1208 // CHECK-SAME: lhs_columns = 16 : i32, lhs_rows = 4 : i32, rhs_columns = 3 : i32
1209 // CHECK-SAME: } : (vector<64xi64>, vector<48xi64>) -> vector<12xi64>
1211 // -----
1213 func @transfer_read_1d(%A : memref<?xf32>, %base: index) -> vector<17xf32> {
1214 %f7 = arith.constant 7.0: f32
1215 %f = vector.transfer_read %A[%base], %f7
1216 {permutation_map = affine_map<(d0) -> (d0)>} :
1217 memref<?xf32>, vector<17xf32>
1218 vector.transfer_write %f, %A[%base]
1219 {permutation_map = affine_map<(d0) -> (d0)>} :
1220 vector<17xf32>, memref<?xf32>
1221 return %f: vector<17xf32>
1222 }
1223 // CHECK-LABEL: func @transfer_read_1d
1224 // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xf32>
1225 // CHECK: %[[c7:.*]] = arith.constant 7.0
1226 // CHECK: %[[C0:.*]] = arith.constant 0 : index
1227 // CHECK: %[[DIM:.*]] = memref.dim %{{.*}}, %[[C0]] : memref<?xf32>
1228 //
1229 // 1. Create a vector with linear indices [ 0 .. vector_length - 1 ].
1230 // CHECK: %[[linearIndex:.*]] = arith.constant dense
1231 // CHECK-SAME: <[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> :
1232 // CHECK-SAME: vector<17xi32>
1233 //
1234 // 2. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].
1235 // CHECK: %[[otrunc:.*]] = arith.index_cast %[[BASE]] : index to i32
1236 // CHECK: %[[offsetVec:.*]] = splat %[[otrunc]] : vector<17xi32>
1237 // CHECK: %[[offsetVec2:.*]] = arith.addi %[[offsetVec]], %[[linearIndex]] : vector<17xi32>
1238 //
1239 // 3. Let dim the memref dimension, compute the vector comparison mask:
1240 // [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ]
1241 // CHECK: %[[dtrunc:.*]] = arith.index_cast %[[DIM]] : index to i32
1242 // CHECK: %[[dimVec:.*]] = splat %[[dtrunc]] : vector<17xi32>
1243 // CHECK: %[[mask:.*]] = arith.cmpi slt, %[[offsetVec2]], %[[dimVec]] : vector<17xi32>
1244 //
1245 // 4. Create pass-through vector.
1246 // CHECK: %[[PASS_THROUGH:.*]] = splat %[[c7]] : vector<17xf32>
1247 //
1248 // 5. Bitcast to vector form.
1249 // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
1250 // CHECK-SAME: (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1251 // CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] :
1252 // CHECK-SAME: !llvm.ptr<f32> to !llvm.ptr<vector<17xf32>>
1253 //
1254 // 6. Rewrite as a masked read.
1255 // CHECK: %[[loaded:.*]] = llvm.intr.masked.load %[[vecPtr]], %[[mask]],
1256 // CHECK-SAME: %[[PASS_THROUGH]] {alignment = 4 : i32} :
1257 // CHECK-SAME: (!llvm.ptr<vector<17xf32>>, vector<17xi1>, vector<17xf32>) -> vector<17xf32>
1258 //
1259 // 1. Create a vector with linear indices [ 0 .. vector_length - 1 ].
1260 // CHECK: %[[linearIndex_b:.*]] = arith.constant dense
1261 // CHECK-SAME: <[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> :
1262 // CHECK-SAME: vector<17xi32>
1263 //
1264 // 2. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].
1265 // CHECK: splat %{{.*}} : vector<17xi32>
1266 // CHECK: arith.addi
1267 //
1268 // 3. Let dim the memref dimension, compute the vector comparison mask:
1269 // [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ]
1270 // CHECK: splat %{{.*}} : vector<17xi32>
1271 // CHECK: %[[mask_b:.*]] = arith.cmpi slt, {{.*}} : vector<17xi32>
1272 //
1273 // 4. Bitcast to vector form.
1274 // CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} :
1275 // CHECK-SAME: (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1276 // CHECK: %[[vecPtr_b:.*]] = llvm.bitcast %[[gep_b]] :
1277 // CHECK-SAME: !llvm.ptr<f32> to !llvm.ptr<vector<17xf32>>
1278 //
1279 // 5. Rewrite as a masked write.
1280 // CHECK: llvm.intr.masked.store %[[loaded]], %[[vecPtr_b]], %[[mask_b]]
1281 // CHECK-SAME: {alignment = 4 : i32} :
1282 // CHECK-SAME: vector<17xf32>, vector<17xi1> into !llvm.ptr<vector<17xf32>>
1284 // -----
1286 func @transfer_read_index_1d(%A : memref<?xindex>, %base: index) -> vector<17xindex> {
1287 %f7 = arith.constant 7: index
1288 %f = vector.transfer_read %A[%base], %f7
1289 {permutation_map = affine_map<(d0) -> (d0)>} :
1290 memref<?xindex>, vector<17xindex>
1291 vector.transfer_write %f, %A[%base]
1292 {permutation_map = affine_map<(d0) -> (d0)>} :
1293 vector<17xindex>, memref<?xindex>
1294 return %f: vector<17xindex>
1295 }
1296 // CHECK-LABEL: func @transfer_read_index_1d
1297 // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xindex>
1298 // CHECK: %[[C7:.*]] = arith.constant 7 : index
1299 // CHECK: %[[SPLAT:.*]] = splat %[[C7]] : vector<17xindex>
1300 // CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[SPLAT]] : vector<17xindex> to vector<17xi64>
1302 // CHECK: %[[loaded:.*]] = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} :
1303 // CHECK-SAME: (!llvm.ptr<vector<17xi64>>, vector<17xi1>, vector<17xi64>) -> vector<17xi64>
1305 // CHECK: llvm.intr.masked.store %[[loaded]], %{{.*}}, %{{.*}} {alignment = 8 : i32} :
1306 // CHECK-SAME: vector<17xi64>, vector<17xi1> into !llvm.ptr<vector<17xi64>>
1308 // -----
1310 func @transfer_read_2d_to_1d(%A : memref<?x?xf32>, %base0: index, %base1: index) -> vector<17xf32> {
1311 %f7 = arith.constant 7.0: f32
1312 %f = vector.transfer_read %A[%base0, %base1], %f7
1313 {permutation_map = affine_map<(d0, d1) -> (d1)>} :
1314 memref<?x?xf32>, vector<17xf32>
1315 return %f: vector<17xf32>
1316 }
1317 // CHECK-LABEL: func @transfer_read_2d_to_1d
1318 // CHECK-SAME: %[[BASE_0:[a-zA-Z0-9]*]]: index, %[[BASE_1:[a-zA-Z0-9]*]]: index) -> vector<17xf32>
1319 // CHECK: %[[c1:.*]] = arith.constant 1 : index
1320 // CHECK: %[[DIM:.*]] = memref.dim %{{.*}}, %[[c1]] : memref<?x?xf32>
1321 //
1322 // Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].
1323 // CHECK: %[[trunc:.*]] = arith.index_cast %[[BASE_1]] : index to i32
1324 // CHECK: %[[offsetVec:.*]] = splat %[[trunc]] : vector<17xi32>
1325 //
1326 // Let dim the memref dimension, compute the vector comparison mask:
1327 // [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ]
1328 // CHECK: %[[dimtrunc:.*]] = arith.index_cast %[[DIM]] : index to i32
1329 // CHECK: splat %[[dimtrunc]] : vector<17xi32>
1331 // -----
1333 func @transfer_read_1d_non_zero_addrspace(%A : memref<?xf32, 3>, %base: index) -> vector<17xf32> {
1334 %f7 = arith.constant 7.0: f32
1335 %f = vector.transfer_read %A[%base], %f7
1336 {permutation_map = affine_map<(d0) -> (d0)>} :
1337 memref<?xf32, 3>, vector<17xf32>
1338 vector.transfer_write %f, %A[%base]
1339 {permutation_map = affine_map<(d0) -> (d0)>} :
1340 vector<17xf32>, memref<?xf32, 3>
1341 return %f: vector<17xf32>
1342 }
1343 // CHECK-LABEL: func @transfer_read_1d_non_zero_addrspace
1344 // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xf32>
1345 //
1346 // 1. Check address space for GEP is correct.
1347 // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
1348 // CHECK-SAME: (!llvm.ptr<f32, 3>, i64) -> !llvm.ptr<f32, 3>
1349 // CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] :
1350 // CHECK-SAME: !llvm.ptr<f32, 3> to !llvm.ptr<vector<17xf32>, 3>
1351 //
1352 // 2. Check address space of the memref is correct.
1353 // CHECK: %[[c0:.*]] = arith.constant 0 : index
1354 // CHECK: %[[DIM:.*]] = memref.dim %{{.*}}, %[[c0]] : memref<?xf32, 3>
1355 //
1356 // 3. Check address space for GEP is correct.
1357 // CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} :
1358 // CHECK-SAME: (!llvm.ptr<f32, 3>, i64) -> !llvm.ptr<f32, 3>
1359 // CHECK: %[[vecPtr_b:.*]] = llvm.bitcast %[[gep_b]] :
1360 // CHECK-SAME: !llvm.ptr<f32, 3> to !llvm.ptr<vector<17xf32>, 3>
1362 // -----
1364 func @transfer_read_1d_inbounds(%A : memref<?xf32>, %base: index) -> vector<17xf32> {
1365 %f7 = arith.constant 7.0: f32
1366 %f = vector.transfer_read %A[%base], %f7 {in_bounds = [true]} :
1367 memref<?xf32>, vector<17xf32>
1368 return %f: vector<17xf32>
1369 }
1370 // CHECK-LABEL: func @transfer_read_1d_inbounds
1371 // CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: index) -> vector<17xf32>
1372 //
1373 // 1. Bitcast to vector form.
1374 // CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
1375 // CHECK-SAME: (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1376 // CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] :
1377 // CHECK-SAME: !llvm.ptr<f32> to !llvm.ptr<vector<17xf32>>
1378 //
1379 // 2. Rewrite as a load.
1380 // CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm.ptr<vector<17xf32>>
1382 // -----
1384 // CHECK-LABEL: func @transfer_read_1d_mask
1385 // CHECK: %[[mask1:.*]] = arith.constant dense<[false, false, true, false, true]>
1386 // CHECK: %[[cmpi:.*]] = arith.cmpi slt
1387 // CHECK: %[[mask2:.*]] = arith.andi %[[cmpi]], %[[mask1]]
1388 // CHECK: %[[r:.*]] = llvm.intr.masked.load %{{.*}}, %[[mask2]]
1389 // CHECK: return %[[r]]
1390 func @transfer_read_1d_mask(%A : memref<?xf32>, %base : index) -> vector<5xf32> {
1391 %m = arith.constant dense<[0, 0, 1, 0, 1]> : vector<5xi1>
1392 %f7 = arith.constant 7.0: f32
1393 %f = vector.transfer_read %A[%base], %f7, %m : memref<?xf32>, vector<5xf32>
1394 return %f: vector<5xf32>
1395 }
1397 // -----
1399 func @genbool_0d_f() -> vector<i1> {
1400 %0 = vector.constant_mask [0] : vector<i1>
1401 return %0 : vector<i1>
1402 }
1403 // CHECK-LABEL: func @genbool_0d_f
1404 // CHECK: %[[VAL_0:.*]] = arith.constant dense<false> : vector<i1>
1405 // CHECK: return %[[VAL_0]] : vector<i1>
1407 // -----
1409 func @genbool_0d_t() -> vector<i1> {
1410 %0 = vector.constant_mask [1] : vector<i1>
1411 return %0 : vector<i1>
1412 }
1413 // CHECK-LABEL: func @genbool_0d_t
1414 // CHECK: %[[VAL_0:.*]] = arith.constant dense<true> : vector<i1>
1415 // CHECK: return %[[VAL_0]] : vector<i1>
1417 // -----
1419 func @genbool_1d() -> vector<8xi1> {
1420 %0 = vector.constant_mask [4] : vector<8xi1>
1421 return %0 : vector<8xi1>
1422 }
1423 // CHECK-LABEL: func @genbool_1d
1424 // CHECK: %[[VAL_0:.*]] = arith.constant dense<[true, true, true, true, false, false, false, false]> : vector<8xi1>
1425 // CHECK: return %[[VAL_0]] : vector<8xi1>
1427 // -----
1429 func @genbool_2d() -> vector<4x4xi1> {
1430 %v = vector.constant_mask [2, 2] : vector<4x4xi1>
1431 return %v: vector<4x4xi1>
1432 }
1434 // CHECK-LABEL: func @genbool_2d
1435 // CHECK: %[[VAL_0:.*]] = arith.constant dense<[true, true, false, false]> : vector<4xi1>
1436 // CHECK: %[[VAL_1:.*]] = arith.constant dense<false> : vector<4x4xi1>
1437 // CHECK: %[[VAL_2:.*]] = builtin.unrealized_conversion_cast %[[VAL_1]] : vector<4x4xi1> to !llvm.array<4 x vector<4xi1>>
1438 // CHECK: %[[VAL_3:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_2]][0] : !llvm.array<4 x vector<4xi1>>
1439 // CHECK: %[[VAL_4:.*]] = llvm.insertvalue %[[VAL_0]], %[[VAL_3]][1] : !llvm.array<4 x vector<4xi1>>
1440 // CHECK: %[[VAL_5:.*]] = builtin.unrealized_conversion_cast %[[VAL_4]] : !llvm.array<4 x vector<4xi1>> to vector<4x4xi1>
1441 // CHECK: return %[[VAL_5]] : vector<4x4xi1>
1443 // -----
1445 func @create_mask_0d(%a : index) -> vector<i1> {
1446 %v = vector.create_mask %a : vector<i1>
1447 return %v: vector<i1>
1448 }
1450 // CHECK-LABEL: func @create_mask_0d
1451 // CHECK-SAME: %[[arg:.*]]: index
1452 // CHECK: %[[indices:.*]] = arith.constant dense<0> : vector<i32>
1453 // CHECK: %[[arg_i32:.*]] = arith.index_cast %[[arg]] : index to i32
1454 // CHECK: %[[bounds:.*]] = splat %[[arg_i32]] : vector<i32>
1455 // CHECK: %[[result:.*]] = arith.cmpi slt, %[[indices]], %[[bounds]] : vector<i32>
1456 // CHECK: return %[[result]] : vector<i1>
1457 // -----
1459 func @create_mask_1d(%a : index) -> vector<4xi1> {
1460 %v = vector.create_mask %a : vector<4xi1>
1461 return %v: vector<4xi1>
1462 }
1464 // CHECK-LABEL: func @create_mask_1d
1465 // CHECK-SAME: %[[arg:.*]]: index
1466 // CHECK: %[[indices:.*]] = arith.constant dense<[0, 1, 2, 3]> : vector<4xi32>
1467 // CHECK: %[[arg_i32:.*]] = arith.index_cast %[[arg]] : index to i32
1468 // CHECK: %[[bounds:.*]] = splat %[[arg_i32]] : vector<4xi32>
1469 // CHECK: %[[result:.*]] = arith.cmpi slt, %[[indices]], %[[bounds]] : vector<4xi32>
1470 // CHECK: return %[[result]] : vector<4xi1>
1472 // -----
1474 func @flat_transpose(%arg0: vector<16xf32>) -> vector<16xf32> {
1475 %0 = vector.flat_transpose %arg0 { rows = 4: i32, columns = 4: i32 }
1476 : vector<16xf32> -> vector<16xf32>
1477 return %0 : vector<16xf32>
1478 }
1480 // CHECK-LABEL: func @flat_transpose
1481 // CHECK-SAME: %[[A:.*]]: vector<16xf32>
1482 // CHECK: %[[T:.*]] = llvm.intr.matrix.transpose %[[A]]
1483 // CHECK-SAME: {columns = 4 : i32, rows = 4 : i32} :
1484 // CHECK-SAME: vector<16xf32> into vector<16xf32>
1485 // CHECK: return %[[T]] : vector<16xf32>
1487 // -----
1489 func @flat_transpose_index(%arg0: vector<16xindex>) -> vector<16xindex> {
1490 %0 = vector.flat_transpose %arg0 { rows = 4: i32, columns = 4: i32 }
1491 : vector<16xindex> -> vector<16xindex>
1492 return %0 : vector<16xindex>
1493 }
1494 // CHECK-LABEL: func @flat_transpose_index
1495 // CHECK-SAME: %[[A:.*]]: vector<16xindex>
1496 // CHECK: %[[T0:.*]] = builtin.unrealized_conversion_cast %[[A]] : vector<16xindex> to vector<16xi64>
1497 // CHECK: %[[T1:.*]] = llvm.intr.matrix.transpose %[[T0]]
1498 // CHECK-SAME: {columns = 4 : i32, rows = 4 : i32} :
1499 // CHECK-SAME: vector<16xi64> into vector<16xi64>
1500 // CHECK: %[[T2:.*]] = builtin.unrealized_conversion_cast %[[T1]] : vector<16xi64> to vector<16xindex>
1501 // CHECK: return %[[T2]] : vector<16xindex>
1503 // -----
1505 func @vector_load_op(%memref : memref<200x100xf32>, %i : index, %j : index) -> vector<8xf32> {
1506 %0 = vector.load %memref[%i, %j] : memref<200x100xf32>, vector<8xf32>
1507 return %0 : vector<8xf32>
1508 }
1510 // CHECK-LABEL: func @vector_load_op
1511 // CHECK: %[[c100:.*]] = llvm.mlir.constant(100 : index) : i64
1512 // CHECK: %[[mul:.*]] = llvm.mul %{{.*}}, %[[c100]] : i64
1513 // CHECK: %[[add:.*]] = llvm.add %[[mul]], %{{.*}} : i64
1514 // CHECK: %[[gep:.*]] = llvm.getelementptr %{{.*}}[%[[add]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1515 // CHECK: %[[bcast:.*]] = llvm.bitcast %[[gep]] : !llvm.ptr<f32> to !llvm.ptr<vector<8xf32>>
1516 // CHECK: llvm.load %[[bcast]] {alignment = 4 : i64} : !llvm.ptr<vector<8xf32>>
1518 // -----
1520 func @vector_load_op_index(%memref : memref<200x100xindex>, %i : index, %j : index) -> vector<8xindex> {
1521 %0 = vector.load %memref[%i, %j] : memref<200x100xindex>, vector<8xindex>
1522 return %0 : vector<8xindex>
1523 }
1524 // CHECK-LABEL: func @vector_load_op_index
1525 // CHECK: %[[T0:.*]] = llvm.load %{{.*}} {alignment = 8 : i64} : !llvm.ptr<vector<8xi64>>
1526 // CHECK: %[[T1:.*]] = builtin.unrealized_conversion_cast %[[T0]] : vector<8xi64> to vector<8xindex>
1527 // CHECK: return %[[T1]] : vector<8xindex>
1529 // -----
1531 func @vector_store_op(%memref : memref<200x100xf32>, %i : index, %j : index) {
1532 %val = arith.constant dense<11.0> : vector<4xf32>
1533 vector.store %val, %memref[%i, %j] : memref<200x100xf32>, vector<4xf32>
1534 return
1535 }
1537 // CHECK-LABEL: func @vector_store_op
1538 // CHECK: %[[c100:.*]] = llvm.mlir.constant(100 : index) : i64
1539 // CHECK: %[[mul:.*]] = llvm.mul %{{.*}}, %[[c100]] : i64
1540 // CHECK: %[[add:.*]] = llvm.add %[[mul]], %{{.*}} : i64
1541 // CHECK: %[[gep:.*]] = llvm.getelementptr %{{.*}}[%[[add]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1542 // CHECK: %[[bcast:.*]] = llvm.bitcast %[[gep]] : !llvm.ptr<f32> to !llvm.ptr<vector<4xf32>>
1543 // CHECK: llvm.store %{{.*}}, %[[bcast]] {alignment = 4 : i64} : !llvm.ptr<vector<4xf32>>
1545 // -----
1547 func @vector_store_op_index(%memref : memref<200x100xindex>, %i : index, %j : index) {
1548 %val = arith.constant dense<11> : vector<4xindex>
1549 vector.store %val, %memref[%i, %j] : memref<200x100xindex>, vector<4xindex>
1550 return
1551 }
1552 // CHECK-LABEL: func @vector_store_op_index
1553 // CHECK: llvm.store %{{.*}}, %{{.*}} {alignment = 8 : i64} : !llvm.ptr<vector<4xi64>>
1555 // -----
1557 func @masked_load_op(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector<16xf32>) -> vector<16xf32> {
1558 %c0 = arith.constant 0: index
1559 %0 = vector.maskedload %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<16xi1>, vector<16xf32> into vector<16xf32>
1560 return %0 : vector<16xf32>
1561 }
1563 // CHECK-LABEL: func @masked_load_op
1564 // CHECK: %[[CO:.*]] = arith.constant 0 : index
1565 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64
1566 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1567 // CHECK: %[[B:.*]] = llvm.bitcast %[[P]] : !llvm.ptr<f32> to !llvm.ptr<vector<16xf32>>
1568 // CHECK: %[[L:.*]] = llvm.intr.masked.load %[[B]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.ptr<vector<16xf32>>, vector<16xi1>, vector<16xf32>) -> vector<16xf32>
1569 // CHECK: return %[[L]] : vector<16xf32>
1571 // -----
1573 func @masked_load_op_index(%arg0: memref<?xindex>, %arg1: vector<16xi1>, %arg2: vector<16xindex>) -> vector<16xindex> {
1574 %c0 = arith.constant 0: index
1575 %0 = vector.maskedload %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<16xi1>, vector<16xindex> into vector<16xindex>
1576 return %0 : vector<16xindex>
1577 }
1578 // CHECK-LABEL: func @masked_load_op_index
1579 // CHECK: %{{.*}} = llvm.intr.masked.load %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.ptr<vector<16xi64>>, vector<16xi1>, vector<16xi64>) -> vector<16xi64>
1581 // -----
1583 func @masked_store_op(%arg0: memref<?xf32>, %arg1: vector<16xi1>, %arg2: vector<16xf32>) {
1584 %c0 = arith.constant 0: index
1585 vector.maskedstore %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<16xi1>, vector<16xf32>
1586 return
1587 }
1589 // CHECK-LABEL: func @masked_store_op
1590 // CHECK: %[[CO:.*]] = arith.constant 0 : index
1591 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64
1592 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1593 // CHECK: %[[B:.*]] = llvm.bitcast %[[P]] : !llvm.ptr<f32> to !llvm.ptr<vector<16xf32>>
1594 // CHECK: llvm.intr.masked.store %{{.*}}, %[[B]], %{{.*}} {alignment = 4 : i32} : vector<16xf32>, vector<16xi1> into !llvm.ptr<vector<16xf32>>
1596 // -----
1598 func @masked_store_op_index(%arg0: memref<?xindex>, %arg1: vector<16xi1>, %arg2: vector<16xindex>) {
1599 %c0 = arith.constant 0: index
1600 vector.maskedstore %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<16xi1>, vector<16xindex>
1601 return
1602 }
1603 // CHECK-LABEL: func @masked_store_op_index
1604 // CHECK: llvm.intr.masked.store %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : vector<16xi64>, vector<16xi1> into !llvm.ptr<vector<16xi64>>
1606 // -----
1608 func @gather_op(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>) -> vector<3xf32> {
1609 %0 = arith.constant 0: index
1610 %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32>, vector<3xi32>, vector<3xi1>, vector<3xf32> into vector<3xf32>
1611 return %1 : vector<3xf32>
1612 }
1614 // CHECK-LABEL: func @gather_op
1615 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<f32>, vector<3xi32>) -> !llvm.vec<3 x ptr<f32>>
1616 // CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.vec<3 x ptr<f32>>, vector<3xi1>, vector<3xf32>) -> vector<3xf32>
1617 // CHECK: return %[[G]] : vector<3xf32>
1619 // -----
1621 func @gather_op_index(%arg0: memref<?xindex>, %arg1: vector<3xindex>, %arg2: vector<3xi1>, %arg3: vector<3xindex>) -> vector<3xindex> {
1622 %0 = arith.constant 0: index
1623 %1 = vector.gather %arg0[%0][%arg1], %arg2, %arg3 : memref<?xindex>, vector<3xindex>, vector<3xi1>, vector<3xindex> into vector<3xindex>
1624 return %1 : vector<3xindex>
1625 }
1627 // CHECK-LABEL: func @gather_op_index
1628 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<i64>, vector<3xi64>) -> !llvm.vec<3 x ptr<i64>>
1629 // CHECK: %[[G:.*]] = llvm.intr.masked.gather %{{.*}}, %{{.*}}, %{{.*}} {alignment = 8 : i32} : (!llvm.vec<3 x ptr<i64>>, vector<3xi1>, vector<3xi64>) -> vector<3xi64>
1630 // CHECK: %{{.*}} = builtin.unrealized_conversion_cast %[[G]] : vector<3xi64> to vector<3xindex>
1632 // -----
1634 func @gather_2d_op(%arg0: memref<4x4xf32>, %arg1: vector<4xi32>, %arg2: vector<4xi1>, %arg3: vector<4xf32>) -> vector<4xf32> {
1635 %0 = arith.constant 3 : index
1636 %1 = vector.gather %arg0[%0, %0][%arg1], %arg2, %arg3 : memref<4x4xf32>, vector<4xi32>, vector<4xi1>, vector<4xf32> into vector<4xf32>
1637 return %1 : vector<4xf32>
1638 }
1640 // CHECK-LABEL: func @gather_2d_op
1641 // CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1642 // CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr<f32>, vector<4xi32>) -> !llvm.vec<4 x ptr<f32>>
1643 // CHECK: %[[G:.*]] = llvm.intr.masked.gather %[[P]], %{{.*}}, %{{.*}} {alignment = 4 : i32} : (!llvm.vec<4 x ptr<f32>>, vector<4xi1>, vector<4xf32>) -> vector<4xf32>
1644 // CHECK: return %[[G]] : vector<4xf32>
1646 // -----
1648 func @scatter_op(%arg0: memref<?xf32>, %arg1: vector<3xi32>, %arg2: vector<3xi1>, %arg3: vector<3xf32>) {
1649 %0 = arith.constant 0: index
1650 vector.scatter %arg0[%0][%arg1], %arg2, %arg3 : memref<?xf32>, vector<3xi32>, vector<3xi1>, vector<3xf32>
1651 return
1652 }
1654 // CHECK-LABEL: func @scatter_op
1655 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<f32>, vector<3xi32>) -> !llvm.vec<3 x ptr<f32>>
1656 // CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<3xf32>, vector<3xi1> into !llvm.vec<3 x ptr<f32>>
1658 // -----
1660 func @scatter_op_index(%arg0: memref<?xindex>, %arg1: vector<3xindex>, %arg2: vector<3xi1>, %arg3: vector<3xindex>) {
1661 %0 = arith.constant 0: index
1662 vector.scatter %arg0[%0][%arg1], %arg2, %arg3 : memref<?xindex>, vector<3xindex>, vector<3xi1>, vector<3xindex>
1663 return
1664 }
1666 // CHECK-LABEL: func @scatter_op_index
1667 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<i64>, vector<3xi64>) -> !llvm.vec<3 x ptr<i64>>
1668 // CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 8 : i32} : vector<3xi64>, vector<3xi1> into !llvm.vec<3 x ptr<i64>>
1670 // -----
1672 func @scatter_2d_op(%arg0: memref<4x4xf32>, %arg1: vector<4xi32>, %arg2: vector<4xi1>, %arg3: vector<4xf32>) {
1673 %0 = arith.constant 3 : index
1674 vector.scatter %arg0[%0, %0][%arg1], %arg2, %arg3 : memref<4x4xf32>, vector<4xi32>, vector<4xi1>, vector<4xf32>
1675 return
1676 }
1678 // CHECK-LABEL: func @scatter_2d_op
1679 // CHECK: %[[B:.*]] = llvm.getelementptr %{{.*}}[%{{.*}}] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1680 // CHECK: %[[P:.*]] = llvm.getelementptr %[[B]][%{{.*}}] : (!llvm.ptr<f32>, vector<4xi32>) -> !llvm.vec<4 x ptr<f32>>
1681 // CHECK: llvm.intr.masked.scatter %{{.*}}, %[[P]], %{{.*}} {alignment = 4 : i32} : vector<4xf32>, vector<4xi1> into !llvm.vec<4 x ptr<f32>>
1683 // -----
1685 func @expand_load_op(%arg0: memref<?xf32>, %arg1: vector<11xi1>, %arg2: vector<11xf32>) -> vector<11xf32> {
1686 %c0 = arith.constant 0: index
1687 %0 = vector.expandload %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<11xi1>, vector<11xf32> into vector<11xf32>
1688 return %0 : vector<11xf32>
1689 }
1691 // CHECK-LABEL: func @expand_load_op
1692 // CHECK: %[[CO:.*]] = arith.constant 0 : index
1693 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64
1694 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1695 // CHECK: %[[E:.*]] = "llvm.intr.masked.expandload"(%[[P]], %{{.*}}, %{{.*}}) : (!llvm.ptr<f32>, vector<11xi1>, vector<11xf32>) -> vector<11xf32>
1696 // CHECK: return %[[E]] : vector<11xf32>
1698 // -----
1700 func @expand_load_op_index(%arg0: memref<?xindex>, %arg1: vector<11xi1>, %arg2: vector<11xindex>) -> vector<11xindex> {
1701 %c0 = arith.constant 0: index
1702 %0 = vector.expandload %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<11xi1>, vector<11xindex> into vector<11xindex>
1703 return %0 : vector<11xindex>
1704 }
1705 // CHECK-LABEL: func @expand_load_op_index
1706 // CHECK: %{{.*}} = "llvm.intr.masked.expandload"(%{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr<i64>, vector<11xi1>, vector<11xi64>) -> vector<11xi64>
1708 // -----
1710 func @compress_store_op(%arg0: memref<?xf32>, %arg1: vector<11xi1>, %arg2: vector<11xf32>) {
1711 %c0 = arith.constant 0: index
1712 vector.compressstore %arg0[%c0], %arg1, %arg2 : memref<?xf32>, vector<11xi1>, vector<11xf32>
1713 return
1714 }
1716 // CHECK-LABEL: func @compress_store_op
1717 // CHECK: %[[CO:.*]] = arith.constant 0 : index
1718 // CHECK: %[[C:.*]] = builtin.unrealized_conversion_cast %[[CO]] : index to i64
1719 // CHECK: %[[P:.*]] = llvm.getelementptr %{{.*}}[%[[C]]] : (!llvm.ptr<f32>, i64) -> !llvm.ptr<f32>
1720 // CHECK: "llvm.intr.masked.compressstore"(%{{.*}}, %[[P]], %{{.*}}) : (vector<11xf32>, !llvm.ptr<f32>, vector<11xi1>) -> ()
1722 // -----
1724 func @compress_store_op_index(%arg0: memref<?xindex>, %arg1: vector<11xi1>, %arg2: vector<11xindex>) {
1725 %c0 = arith.constant 0: index
1726 vector.compressstore %arg0[%c0], %arg1, %arg2 : memref<?xindex>, vector<11xi1>, vector<11xindex>
1727 return
1728 }
1729 // CHECK-LABEL: func @compress_store_op_index
1730 // CHECK: "llvm.intr.masked.compressstore"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<11xi64>, !llvm.ptr<i64>, vector<11xi1>) -> ()