1// RUN: mlir-opt %s -convert-vector-to-llvm | FileCheck %s
2
3func @broadcast_vec1d_from_scalar(%arg0: f32) -> vector<2xf32> {
4  %0 = vector.broadcast %arg0 : f32 to vector<2xf32>
5  return %0 : vector<2xf32>
6}
7// CHECK-LABEL: llvm.func @broadcast_vec1d_from_scalar(
8// CHECK-SAME:  %[[A:.*]]: !llvm.float)
9// CHECK:       %[[T0:.*]] = llvm.mlir.undef : !llvm<"<2 x float>">
10// CHECK:       %[[T1:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
11// CHECK:       %[[T2:.*]] = llvm.insertelement %[[A]], %[[T0]][%[[T1]] : !llvm.i32] : !llvm<"<2 x float>">
12// CHECK:       %[[T3:.*]] = llvm.shufflevector %[[T2]], %[[T0]] [0 : i32, 0 : i32] : !llvm<"<2 x float>">, !llvm<"<2 x float>">
13// CHECK:       llvm.return %[[T3]] : !llvm<"<2 x float>">
14
15func @broadcast_vec2d_from_scalar(%arg0: f32) -> vector<2x3xf32> {
16  %0 = vector.broadcast %arg0 : f32 to vector<2x3xf32>
17  return %0 : vector<2x3xf32>
18}
19// CHECK-LABEL: llvm.func @broadcast_vec2d_from_scalar(
20// CHECK-SAME:  %[[A:.*]]: !llvm.float)
21// CHECK:       %[[T0:.*]] = llvm.mlir.undef : !llvm<"[2 x <3 x float>]">
22// CHECK:       %[[T1:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
23// CHECK:       %[[T2:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
24// CHECK:       %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : !llvm.i32] : !llvm<"<3 x float>">
25// CHECK:       %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
26// CHECK:       %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T0]][0] : !llvm<"[2 x <3 x float>]">
27// CHECK:       %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][1] : !llvm<"[2 x <3 x float>]">
28// CHECK:       llvm.return %[[T6]] : !llvm<"[2 x <3 x float>]">
29
30func @broadcast_vec3d_from_scalar(%arg0: f32) -> vector<2x3x4xf32> {
31  %0 = vector.broadcast %arg0 : f32 to vector<2x3x4xf32>
32  return %0 : vector<2x3x4xf32>
33}
34// CHECK-LABEL: llvm.func @broadcast_vec3d_from_scalar(
35// CHECK-SAME:  %[[A:.*]]: !llvm.float)
36// CHECK:       %[[T0:.*]] = llvm.mlir.undef : !llvm<"[2 x [3 x <4 x float>]]">
37// CHECK:       %[[T1:.*]] = llvm.mlir.undef : !llvm<"<4 x float>">
38// CHECK:       %[[T2:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
39// CHECK:       %[[T3:.*]] = llvm.insertelement %[[A]], %[[T1]][%[[T2]] : !llvm.i32] : !llvm<"<4 x float>">
40// CHECK:       %[[T4:.*]] = llvm.shufflevector %[[T3]], %[[T3]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm<"<4 x float>">, !llvm<"<4 x float>">
41// CHECK:       %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T0]][0, 0] : !llvm<"[2 x [3 x <4 x float>]]">
42// CHECK:       %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][0, 1] : !llvm<"[2 x [3 x <4 x float>]]">
43// CHECK:       %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][0, 2] : !llvm<"[2 x [3 x <4 x float>]]">
44// CHECK:       %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][1, 0] : !llvm<"[2 x [3 x <4 x float>]]">
45// CHECK:       %[[T9:.*]] = llvm.insertvalue %[[T4]], %[[T8]][1, 1] : !llvm<"[2 x [3 x <4 x float>]]">
46// CHECK:       %[[T10:.*]] = llvm.insertvalue %[[T4]], %[[T9]][1, 2] : !llvm<"[2 x [3 x <4 x float>]]">
47// CHECK:       llvm.return %[[T10]] : !llvm<"[2 x [3 x <4 x float>]]">
48
49func @broadcast_vec1d_from_vec1d(%arg0: vector<2xf32>) -> vector<2xf32> {
50  %0 = vector.broadcast %arg0 : vector<2xf32> to vector<2xf32>
51  return %0 : vector<2xf32>
52}
53// CHECK-LABEL: llvm.func @broadcast_vec1d_from_vec1d(
54// CHECK-SAME:  %[[A:.*]]: !llvm<"<2 x float>">)
55// CHECK:       llvm.return %[[A]] : !llvm<"<2 x float>">
56
57func @broadcast_vec2d_from_vec1d(%arg0: vector<2xf32>) -> vector<3x2xf32> {
58  %0 = vector.broadcast %arg0 : vector<2xf32> to vector<3x2xf32>
59  return %0 : vector<3x2xf32>
60}
61// CHECK-LABEL: llvm.func @broadcast_vec2d_from_vec1d(
62// CHECK-SAME:  %[[A:.*]]: !llvm<"<2 x float>">)
63// CHECK:       %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x2xf32>) : !llvm<"[3 x <2 x float>]">
64// CHECK:       %[[T1:.*]] = llvm.insertvalue %[[A]], %[[T0]][0] : !llvm<"[3 x <2 x float>]">
65// CHECK:       %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T1]][1] : !llvm<"[3 x <2 x float>]">
66// CHECK:       %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][2] : !llvm<"[3 x <2 x float>]">
67// CHECK:       llvm.return %[[T3]] : !llvm<"[3 x <2 x float>]">
68
69func @broadcast_vec3d_from_vec1d(%arg0: vector<2xf32>) -> vector<4x3x2xf32> {
70  %0 = vector.broadcast %arg0 : vector<2xf32> to vector<4x3x2xf32>
71  return %0 : vector<4x3x2xf32>
72}
73// CHECK-LABEL: llvm.func @broadcast_vec3d_from_vec1d(
74// CHECK-SAME:  %[[A:.*]]: !llvm<"<2 x float>">)
75// CHECK:       %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x2xf32>) : !llvm<"[3 x <2 x float>]">
76// CHECK:       %[[T1:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3x2xf32>) : !llvm<"[4 x [3 x <2 x float>]]">
77// CHECK:       %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T0]][0] : !llvm<"[3 x <2 x float>]">
78// CHECK:       %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][1] : !llvm<"[3 x <2 x float>]">
79// CHECK:       %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][2] : !llvm<"[3 x <2 x float>]">
80// CHECK:       %[[T5:.*]] = llvm.insertvalue %[[T4]], %[[T1]][0] : !llvm<"[4 x [3 x <2 x float>]]">
81// CHECK:       %[[T6:.*]] = llvm.insertvalue %[[T4]], %[[T5]][1] : !llvm<"[4 x [3 x <2 x float>]]">
82// CHECK:       %[[T7:.*]] = llvm.insertvalue %[[T4]], %[[T6]][2] : !llvm<"[4 x [3 x <2 x float>]]">
83// CHECK:       %[[T8:.*]] = llvm.insertvalue %[[T4]], %[[T7]][3] : !llvm<"[4 x [3 x <2 x float>]]">
84// CHECK:       llvm.return %[[T8]] : !llvm<"[4 x [3 x <2 x float>]]">
85
86func @broadcast_vec3d_from_vec2d(%arg0: vector<3x2xf32>) -> vector<4x3x2xf32> {
87  %0 = vector.broadcast %arg0 : vector<3x2xf32> to vector<4x3x2xf32>
88  return %0 : vector<4x3x2xf32>
89}
90// CHECK-LABEL: llvm.func @broadcast_vec3d_from_vec2d(
91// CHECK-SAME:  %[[A:.*]]: !llvm<"[3 x <2 x float>]">)
92// CHECK:       %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3x2xf32>) : !llvm<"[4 x [3 x <2 x float>]]">
93// CHECK:       %[[T1:.*]] = llvm.insertvalue %[[A]], %[[T0]][0] : !llvm<"[4 x [3 x <2 x float>]]">
94// CHECK:       %[[T2:.*]] = llvm.insertvalue %[[A]], %[[T1]][1] : !llvm<"[4 x [3 x <2 x float>]]">
95// CHECK:       %[[T3:.*]] = llvm.insertvalue %[[A]], %[[T2]][2] : !llvm<"[4 x [3 x <2 x float>]]">
96// CHECK:       %[[T4:.*]] = llvm.insertvalue %[[A]], %[[T3]][3] : !llvm<"[4 x [3 x <2 x float>]]">
97// CHECK:       llvm.return %[[T4]] : !llvm<"[4 x [3 x <2 x float>]]">
98
99func @broadcast_stretch(%arg0: vector<1xf32>) -> vector<4xf32> {
100  %0 = vector.broadcast %arg0 : vector<1xf32> to vector<4xf32>
101  return %0 : vector<4xf32>
102}
103// CHECK-LABEL: llvm.func @broadcast_stretch(
104// CHECK-SAME:  %[[A:.*]]: !llvm<"<1 x float>">)
105// CHECK:       %[[T0:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64
106// CHECK:       %[[T1:.*]] = llvm.extractelement %[[A]][%[[T0]] : !llvm.i64] : !llvm<"<1 x float>">
107// CHECK:       %[[T2:.*]] = llvm.mlir.undef : !llvm<"<4 x float>">
108// CHECK:       %[[T3:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
109// CHECK:       %[[T4:.*]] = llvm.insertelement %[[T1]], %[[T2]][%3 : !llvm.i32] : !llvm<"<4 x float>">
110// CHECK:       %[[T5:.*]] = llvm.shufflevector %[[T4]], %[[T2]] [0 : i32, 0 : i32, 0 : i32, 0 : i32] : !llvm<"<4 x float>">, !llvm<"<4 x float>">
111// CHECK:       llvm.return %[[T5]] : !llvm<"<4 x float>">
112
113func @broadcast_stretch_at_start(%arg0: vector<1x4xf32>) -> vector<3x4xf32> {
114  %0 = vector.broadcast %arg0 : vector<1x4xf32> to vector<3x4xf32>
115  return %0 : vector<3x4xf32>
116}
117// CHECK-LABEL: llvm.func @broadcast_stretch_at_start(
118// CHECK-SAME:  %[[A:.*]]: !llvm<"[1 x <4 x float>]">)
119// CHECK:       %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x4xf32>) : !llvm<"[3 x <4 x float>]">
120// CHECK:       %[[T1:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[1 x <4 x float>]">
121// CHECK:       %[[T2:.*]] = llvm.insertvalue %[[T1]], %[[T0]][0] : !llvm<"[3 x <4 x float>]">
122// CHECK:       %[[T3:.*]] = llvm.insertvalue %[[T1]], %[[T2]][1] : !llvm<"[3 x <4 x float>]">
123// CHECK:       %[[T4:.*]] = llvm.insertvalue %[[T1]], %[[T3]][2] : !llvm<"[3 x <4 x float>]">
124// CHECK:       llvm.return %[[T4]] : !llvm<"[3 x <4 x float>]">
125
126func @broadcast_stretch_at_end(%arg0: vector<4x1xf32>) -> vector<4x3xf32> {
127  %0 = vector.broadcast %arg0 : vector<4x1xf32> to vector<4x3xf32>
128  return %0 : vector<4x3xf32>
129}
130// CHECK-LABEL: llvm.func @broadcast_stretch_at_end(
131// CHECK-SAME:  %[[A:.*]]: !llvm<"[4 x <1 x float>]">)
132// CHECK:       %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3xf32>) : !llvm<"[4 x <3 x float>]">
133// CHECK:       %[[T1:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[4 x <1 x float>]">
134// CHECK:       %[[T2:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64
135// CHECK:       %[[T3:.*]] = llvm.extractelement %[[T1]][%[[T2]] : !llvm.i64] : !llvm<"<1 x float>">
136// CHECK:       %[[T4:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
137// CHECK:       %[[T5:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
138// CHECK:       %[[T6:.*]] = llvm.insertelement %[[T3]], %[[T4]][%[[T5]] : !llvm.i32] : !llvm<"<3 x float>">
139// CHECK:       %[[T7:.*]] = llvm.shufflevector %[[T6]], %[[T4]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
140// CHECK:       %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T0]][0] : !llvm<"[4 x <3 x float>]">
141// CHECK:       %[[T9:.*]] = llvm.extractvalue %[[A]][1] : !llvm<"[4 x <1 x float>]">
142// CHECK:       %[[T10:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64
143// CHECK:       %[[T11:.*]] = llvm.extractelement %[[T9]][%[[T10]] : !llvm.i64] : !llvm<"<1 x float>">
144// CHECK:       %[[T12:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
145// CHECK:       %[[T13:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
146// CHECK:       %[[T14:.*]] = llvm.insertelement %[[T11]], %[[T12]][%[[T13]] : !llvm.i32] : !llvm<"<3 x float>">
147// CHECK:       %[[T15:.*]] = llvm.shufflevector %[[T14]], %[[T12]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
148// CHECK:       %[[T16:.*]] = llvm.insertvalue %[[T15]], %[[T8]][1] : !llvm<"[4 x <3 x float>]">
149// CHECK:       %[[T17:.*]] = llvm.extractvalue %[[A]][2] : !llvm<"[4 x <1 x float>]">
150// CHECK:       %[[T18:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64
151// CHECK:       %[[T19:.*]] = llvm.extractelement %[[T17]][%[[T18]] : !llvm.i64] : !llvm<"<1 x float>">
152// CHECK:       %[[T20:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
153// CHECK:       %[[T21:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
154// CHECK:       %[[T22:.*]] = llvm.insertelement %[[T19]], %[[T20]][%[[T21]] : !llvm.i32] : !llvm<"<3 x float>">
155// CHECK:       %[[T23:.*]] = llvm.shufflevector %[[T22]], %[[T20]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
156// CHECK:       %[[T24:.*]] = llvm.insertvalue %[[T23]], %[[T16]][2] : !llvm<"[4 x <3 x float>]">
157// CHECK:       %[[T25:.*]] = llvm.extractvalue %[[A]][3] : !llvm<"[4 x <1 x float>]">
158// CHECK:       %[[T26:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64
159// CHECK:       %[[T27:.*]] = llvm.extractelement %[[T25]][%[[T26]] : !llvm.i64] : !llvm<"<1 x float>">
160// CHECK:       %[[T28:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
161// CHECK:       %[[T29:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
162// CHECK:       %[[T30:.*]] = llvm.insertelement %[[T27]], %[[T28]][%[[T29]] : !llvm.i32] : !llvm<"<3 x float>">
163// CHECK:       %[[T31:.*]] = llvm.shufflevector %[[T30]], %[[T28]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
164// CHECK:       %[[T32:.*]] = llvm.insertvalue %[[T31]], %[[T24]][3] : !llvm<"[4 x <3 x float>]">
165// CHECK:       llvm.return %[[T32]] : !llvm<"[4 x <3 x float>]">
166
167func @broadcast_stretch_in_middle(%arg0: vector<4x1x2xf32>) -> vector<4x3x2xf32> {
168  %0 = vector.broadcast %arg0 : vector<4x1x2xf32> to vector<4x3x2xf32>
169  return %0 : vector<4x3x2xf32>
170}
171// CHECK-LABEL: llvm.func @broadcast_stretch_in_middle(
172// CHECK-SAME:  %[[A:.*]]: !llvm<"[4 x [1 x <2 x float>]]">)
173// CHECK:       %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<4x3x2xf32>) : !llvm<"[4 x [3 x <2 x float>]]">
174// CHECK:       %[[T1:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<3x2xf32>) : !llvm<"[3 x <2 x float>]">
175// CHECK:       %[[T2:.*]] = llvm.extractvalue %[[A]][0, 0] : !llvm<"[4 x [1 x <2 x float>]]">
176// CHECK:       %[[T4:.*]] = llvm.insertvalue %[[T2]], %[[T1]][0] : !llvm<"[3 x <2 x float>]">
177// CHECK:       %[[T5:.*]] = llvm.insertvalue %[[T2]], %[[T4]][1] : !llvm<"[3 x <2 x float>]">
178// CHECK:       %[[T6:.*]] = llvm.insertvalue %[[T2]], %[[T5]][2] : !llvm<"[3 x <2 x float>]">
179// CHECK:       %[[T7:.*]] = llvm.insertvalue %[[T6]], %[[T0]][0] : !llvm<"[4 x [3 x <2 x float>]]">
180// CHECK:       %[[T8:.*]] = llvm.extractvalue %[[A]][1, 0] : !llvm<"[4 x [1 x <2 x float>]]">
181// CHECK:       %[[T10:.*]] = llvm.insertvalue %[[T8]], %[[T1]][0] : !llvm<"[3 x <2 x float>]">
182// CHECK:       %[[T11:.*]] = llvm.insertvalue %[[T8]], %[[T10]][1] : !llvm<"[3 x <2 x float>]">
183// CHECK:       %[[T12:.*]] = llvm.insertvalue %[[T8]], %[[T11]][2] : !llvm<"[3 x <2 x float>]">
184// CHECK:       %[[T13:.*]] = llvm.insertvalue %[[T12]], %[[T7]][1] : !llvm<"[4 x [3 x <2 x float>]]">
185// CHECK:       %[[T14:.*]] = llvm.extractvalue %[[A]][2, 0] : !llvm<"[4 x [1 x <2 x float>]]">
186// CHECK:       %[[T16:.*]] = llvm.insertvalue %[[T14]], %[[T1]][0] : !llvm<"[3 x <2 x float>]">
187// CHECK:       %[[T17:.*]] = llvm.insertvalue %[[T14]], %[[T16]][1] : !llvm<"[3 x <2 x float>]">
188// CHECK:       %[[T18:.*]] = llvm.insertvalue %[[T14]], %[[T17]][2] : !llvm<"[3 x <2 x float>]">
189// CHECK:       %[[T19:.*]] = llvm.insertvalue %[[T18]], %[[T13]][2] : !llvm<"[4 x [3 x <2 x float>]]">
190// CHECK:       %[[T20:.*]] = llvm.extractvalue %[[A]][3, 0] : !llvm<"[4 x [1 x <2 x float>]]">
191// CHECK:       %[[T22:.*]] = llvm.insertvalue %[[T20]], %[[T1]][0] : !llvm<"[3 x <2 x float>]">
192// CHECK:       %[[T23:.*]] = llvm.insertvalue %[[T20]], %[[T22]][1] : !llvm<"[3 x <2 x float>]">
193// CHECK:       %[[T24:.*]] = llvm.insertvalue %[[T20]], %[[T23]][2] : !llvm<"[3 x <2 x float>]">
194// CHECK:       %[[T25:.*]] = llvm.insertvalue %[[T24]], %[[T19]][3] : !llvm<"[4 x [3 x <2 x float>]]">
195// CHECK:       llvm.return %[[T25]] : !llvm<"[4 x [3 x <2 x float>]]">
196
197func @outerproduct(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<2x3xf32> {
198  %2 = vector.outerproduct %arg0, %arg1 : vector<2xf32>, vector<3xf32>
199  return %2 : vector<2x3xf32>
200}
201// CHECK-LABEL: llvm.func @outerproduct(
202// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">,
203// CHECK-SAME: %[[B:.*]]: !llvm<"<3 x float>">)
204//      CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<2x3xf32>)
205//      CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64
206//      CHECK: %[[T2:.*]] = llvm.extractelement %[[A]][%[[T1]] : !llvm.i64] : !llvm<"<2 x float>">
207//      CHECK: %[[T3:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
208//      CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
209//      CHECK: %[[T5:.*]] = llvm.insertelement %[[T2]], %[[T3]][%4 : !llvm.i32] : !llvm<"<3 x float>">
210//      CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
211//      CHECK: %[[T7:.*]] = llvm.fmul %[[T6]], %[[B]] : !llvm<"<3 x float>">
212//      CHECK: %[[T8:.*]] = llvm.insertvalue %[[T7]], %[[T0]][0] : !llvm<"[2 x <3 x float>]">
213//      CHECK: %[[T9:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i64
214//      CHECK: %[[T10:.*]] = llvm.extractelement %[[A]][%9 : !llvm.i64] : !llvm<"<2 x float>">
215//      CHECK: %[[T11:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
216//      CHECK: %[[T12:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
217//      CHECK: %[[T13:.*]] = llvm.insertelement %[[T10]], %[[T11]][%12 : !llvm.i32] : !llvm<"<3 x float>">
218//      CHECK: %[[T14:.*]] = llvm.shufflevector %[[T13]], %[[T11]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
219//      CHECK: %[[T15:.*]] = llvm.fmul %[[T14]], %[[B]] : !llvm<"<3 x float>">
220//      CHECK: %[[T16:.*]] = llvm.insertvalue %[[T15]], %[[T8]][1] : !llvm<"[2 x <3 x float>]">
221//      CHECK: llvm.return %[[T16]] : !llvm<"[2 x <3 x float>]">
222
223func @outerproduct_add(%arg0: vector<2xf32>, %arg1: vector<3xf32>, %arg2: vector<2x3xf32>) -> vector<2x3xf32> {
224  %2 = vector.outerproduct %arg0, %arg1, %arg2 : vector<2xf32>, vector<3xf32>
225  return %2 : vector<2x3xf32>
226}
227// CHECK-LABEL: llvm.func @outerproduct_add(
228// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">,
229// CHECK-SAME: %[[B:.*]]: !llvm<"<3 x float>">,
230// CHECK-SAME: %[[C:.*]]: !llvm<"[2 x <3 x float>]">)
231//      CHECK: %[[T0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<2x3xf32>)
232//      CHECK: %[[T1:.*]] = llvm.mlir.constant(0 : i64) : !llvm.i64
233//      CHECK: %[[T2:.*]] = llvm.extractelement %[[A]][%[[T1]] : !llvm.i64] : !llvm<"<2 x float>">
234//      CHECK: %[[T3:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
235//      CHECK: %[[T4:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
236//      CHECK: %[[T5:.*]] = llvm.insertelement %[[T2]], %[[T3]][%[[T4]] : !llvm.i32] : !llvm<"<3 x float>">
237//      CHECK: %[[T6:.*]] = llvm.shufflevector %[[T5]], %[[T3]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
238//      CHECK: %[[T7:.*]] = llvm.extractvalue %[[C]][0] : !llvm<"[2 x <3 x float>]">
239//      CHECK: %[[T8:.*]] = "llvm.intr.fmuladd"(%[[T6]], %[[B]], %[[T7]]) : (!llvm<"<3 x float>">, !llvm<"<3 x float>">, !llvm<"<3 x float>">)
240//      CHECK: %[[T9:.*]] = llvm.insertvalue %[[T8]], %[[T0]][0] : !llvm<"[2 x <3 x float>]">
241//      CHECK: %[[T10:.*]] = llvm.mlir.constant(1 : i64) : !llvm.i64
242//      CHECK: %[[T11:.*]] = llvm.extractelement %[[A]][%[[T10]] : !llvm.i64] : !llvm<"<2 x float>">
243//      CHECK: %[[T12:.*]] = llvm.mlir.undef : !llvm<"<3 x float>">
244//      CHECK: %[[T13:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
245//      CHECK: %[[T14:.*]] = llvm.insertelement %[[T11]], %[[T12]][%[[T13]] : !llvm.i32] : !llvm<"<3 x float>">
246//      CHECK: %[[T15:.*]] = llvm.shufflevector %[[T14]], %[[T12]] [0 : i32, 0 : i32, 0 : i32] : !llvm<"<3 x float>">, !llvm<"<3 x float>">
247//      CHECK: %[[T16:.*]] = llvm.extractvalue %[[C]][1] : !llvm<"[2 x <3 x float>]">
248//      CHECK: %[[T17:.*]] = "llvm.intr.fmuladd"(%[[T15]], %[[B]], %[[T16]]) : (!llvm<"<3 x float>">, !llvm<"<3 x float>">, !llvm<"<3 x float>">)
249//      CHECK: %[[T18:.*]] = llvm.insertvalue %[[T17]], %[[T9]][1] : !llvm<"[2 x <3 x float>]">
250//      CHECK: llvm.return %[[T18]] : !llvm<"[2 x <3 x float>]">
251
252func @shuffle_1D_direct(%arg0: vector<2xf32>, %arg1: vector<2xf32>) -> vector<2xf32> {
253  %1 = vector.shuffle %arg0, %arg1 [0, 1] : vector<2xf32>, vector<2xf32>
254  return %1 : vector<2xf32>
255}
256// CHECK-LABEL: llvm.func @shuffle_1D_direct(
257// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">,
258// CHECK-SAME: %[[B:.*]]: !llvm<"<2 x float>">)
259//       CHECK:   %[[s:.*]] = llvm.shufflevector %[[A]], %[[B]] [0, 1] : !llvm<"<2 x float>">, !llvm<"<2 x float>">
260//       CHECK:   llvm.return %[[s]] : !llvm<"<2 x float>">
261
262func @shuffle_1D(%arg0: vector<2xf32>, %arg1: vector<3xf32>) -> vector<5xf32> {
263  %1 = vector.shuffle %arg0, %arg1 [4, 3, 2, 1, 0] : vector<2xf32>, vector<3xf32>
264  return %1 : vector<5xf32>
265}
266// CHECK-LABEL: llvm.func @shuffle_1D(
267// CHECK-SAME: %[[A:.*]]: !llvm<"<2 x float>">,
268// CHECK-SAME: %[[B:.*]]: !llvm<"<3 x float>">)
269//       CHECK:   %[[u0:.*]] = llvm.mlir.undef : !llvm<"<5 x float>">
270//       CHECK:   %[[c2:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64
271//       CHECK:   %[[e1:.*]] = llvm.extractelement %[[B]][%[[c2]] : !llvm.i64] : !llvm<"<3 x float>">
272//       CHECK:   %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
273//       CHECK:   %[[i1:.*]] = llvm.insertelement %[[e1]], %[[u0]][%[[c0]] : !llvm.i64] : !llvm<"<5 x float>">
274//       CHECK:   %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
275//       CHECK:   %[[e2:.*]] = llvm.extractelement %[[B]][%[[c1]] : !llvm.i64] : !llvm<"<3 x float>">
276//       CHECK:   %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
277//       CHECK:   %[[i2:.*]] = llvm.insertelement %[[e2]], %[[i1]][%[[c1]] : !llvm.i64] : !llvm<"<5 x float>">
278//       CHECK:   %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
279//       CHECK:   %[[e3:.*]] = llvm.extractelement %[[B]][%[[c0]] : !llvm.i64] : !llvm<"<3 x float>">
280//       CHECK:   %[[c2:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64
281//       CHECK:   %[[i3:.*]] = llvm.insertelement %[[e3]], %[[i2]][%[[c2]] : !llvm.i64] : !llvm<"<5 x float>">
282//       CHECK:   %[[c1:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
283//       CHECK:   %[[e4:.*]] = llvm.extractelement %[[A]][%[[c1]] : !llvm.i64] : !llvm<"<2 x float>">
284//       CHECK:   %[[c3:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64
285//       CHECK:   %[[i4:.*]] = llvm.insertelement %[[e4]], %[[i3]][%[[c3]] : !llvm.i64] : !llvm<"<5 x float>">
286//       CHECK:   %[[c0:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
287//       CHECK:   %[[e5:.*]] = llvm.extractelement %[[A]][%[[c0]] : !llvm.i64] : !llvm<"<2 x float>">
288//       CHECK:   %[[c4:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64
289//       CHECK:   %[[i5:.*]] = llvm.insertelement %[[e5]], %[[i4]][%[[c4]] : !llvm.i64] : !llvm<"<5 x float>">
290//       CHECK:   llvm.return %[[i5]] : !llvm<"<5 x float>">
291
292func @shuffle_2D(%a: vector<1x4xf32>, %b: vector<2x4xf32>) -> vector<3x4xf32> {
293  %1 = vector.shuffle %a, %b[1, 0, 2] : vector<1x4xf32>, vector<2x4xf32>
294  return %1 : vector<3x4xf32>
295}
296// CHECK-LABEL: llvm.func @shuffle_2D(
297// CHECK-SAME: %[[A:.*]]: !llvm<"[1 x <4 x float>]">,
298// CHECK-SAME: %[[B:.*]]: !llvm<"[2 x <4 x float>]">)
299//       CHECK:   %[[u0:.*]] = llvm.mlir.undef : !llvm<"[3 x <4 x float>]">
300//       CHECK:   %[[e1:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[2 x <4 x float>]">
301//       CHECK:   %[[i1:.*]] = llvm.insertvalue %[[e1]], %[[u0]][0] : !llvm<"[3 x <4 x float>]">
302//       CHECK:   %[[e2:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[1 x <4 x float>]">
303//       CHECK:   %[[i2:.*]] = llvm.insertvalue %[[e2]], %[[i1]][1] : !llvm<"[3 x <4 x float>]">
304//       CHECK:   %[[e3:.*]] = llvm.extractvalue %[[B]][1] : !llvm<"[2 x <4 x float>]">
305//       CHECK:   %[[i3:.*]] = llvm.insertvalue %[[e3]], %[[i2]][2] : !llvm<"[3 x <4 x float>]">
306//       CHECK:   llvm.return %[[i3]] : !llvm<"[3 x <4 x float>]">
307
308func @extract_element(%arg0: vector<16xf32>) -> f32 {
309  %0 = constant 15 : i32
310  %1 = vector.extractelement %arg0[%0 : i32]: vector<16xf32>
311  return %1 : f32
312}
313// CHECK-LABEL: llvm.func @extract_element(
314// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x float>">)
315//       CHECK:   %[[c:.*]] = llvm.mlir.constant(15 : i32) : !llvm.i32
316//       CHECK:   %[[x:.*]] = llvm.extractelement %[[A]][%[[c]] : !llvm.i32] : !llvm<"<16 x float>">
317//       CHECK:   llvm.return %[[x]] : !llvm.float
318
319func @extract_element_from_vec_1d(%arg0: vector<16xf32>) -> f32 {
320  %0 = vector.extract %arg0[15]: vector<16xf32>
321  return %0 : f32
322}
323// CHECK-LABEL: llvm.func @extract_element_from_vec_1d
324//       CHECK:   llvm.mlir.constant(15 : i64) : !llvm.i64
325//       CHECK:   llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>">
326//       CHECK:   llvm.return {{.*}} : !llvm.float
327
328func @extract_vec_2d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<3x16xf32> {
329  %0 = vector.extract %arg0[0]: vector<4x3x16xf32>
330  return %0 : vector<3x16xf32>
331}
332// CHECK-LABEL: llvm.func @extract_vec_2d_from_vec_3d
333//       CHECK:   llvm.extractvalue {{.*}}[0] : !llvm<"[4 x [3 x <16 x float>]]">
334//       CHECK:   llvm.return {{.*}} : !llvm<"[3 x <16 x float>]">
335
336func @extract_vec_1d_from_vec_3d(%arg0: vector<4x3x16xf32>) -> vector<16xf32> {
337  %0 = vector.extract %arg0[0, 0]: vector<4x3x16xf32>
338  return %0 : vector<16xf32>
339}
340// CHECK-LABEL: llvm.func @extract_vec_1d_from_vec_3d
341//       CHECK:   llvm.extractvalue {{.*}}[0, 0] : !llvm<"[4 x [3 x <16 x float>]]">
342//       CHECK:   llvm.return {{.*}} : !llvm<"<16 x float>">
343
344func @extract_element_from_vec_3d(%arg0: vector<4x3x16xf32>) -> f32 {
345  %0 = vector.extract %arg0[0, 0, 0]: vector<4x3x16xf32>
346  return %0 : f32
347}
348// CHECK-LABEL: llvm.func @extract_element_from_vec_3d
349//       CHECK:   llvm.extractvalue {{.*}}[0, 0] : !llvm<"[4 x [3 x <16 x float>]]">
350//       CHECK:   llvm.mlir.constant(0 : i64) : !llvm.i64
351//       CHECK:   llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>">
352//       CHECK:   llvm.return {{.*}} : !llvm.float
353
354func @insert_element(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
355  %0 = constant 3 : i32
356  %1 = vector.insertelement %arg0, %arg1[%0 : i32] : vector<4xf32>
357  return %1 : vector<4xf32>
358}
359// CHECK-LABEL: llvm.func @insert_element(
360// CHECK-SAME: %[[A:.*]]: !llvm.float,
361// CHECK-SAME: %[[B:.*]]: !llvm<"<4 x float>">)
362//       CHECK:   %[[c:.*]] = llvm.mlir.constant(3 : i32) : !llvm.i32
363//       CHECK:   %[[x:.*]] = llvm.insertelement %[[A]], %[[B]][%[[c]] : !llvm.i32] : !llvm<"<4 x float>">
364//       CHECK:   llvm.return %[[x]] : !llvm<"<4 x float>">
365
366func @insert_element_into_vec_1d(%arg0: f32, %arg1: vector<4xf32>) -> vector<4xf32> {
367  %0 = vector.insert %arg0, %arg1[3] : f32 into vector<4xf32>
368  return %0 : vector<4xf32>
369}
370// CHECK-LABEL: llvm.func @insert_element_into_vec_1d
371//       CHECK:   llvm.mlir.constant(3 : i64) : !llvm.i64
372//       CHECK:   llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
373//       CHECK:   llvm.return {{.*}} : !llvm<"<4 x float>">
374
375func @insert_vec_2d_into_vec_3d(%arg0: vector<8x16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
376  %0 = vector.insert %arg0, %arg1[3] : vector<8x16xf32> into vector<4x8x16xf32>
377  return %0 : vector<4x8x16xf32>
378}
379// CHECK-LABEL: llvm.func @insert_vec_2d_into_vec_3d
380//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm<"[4 x [8 x <16 x float>]]">
381//       CHECK:   llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]">
382
383func @insert_vec_1d_into_vec_3d(%arg0: vector<16xf32>, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
384  %0 = vector.insert %arg0, %arg1[3, 7] : vector<16xf32> into vector<4x8x16xf32>
385  return %0 : vector<4x8x16xf32>
386}
387// CHECK-LABEL: llvm.func @insert_vec_1d_into_vec_3d
388//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]">
389//       CHECK:   llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]">
390
391func @insert_element_into_vec_3d(%arg0: f32, %arg1: vector<4x8x16xf32>) -> vector<4x8x16xf32> {
392  %0 = vector.insert %arg0, %arg1[3, 7, 15] : f32 into vector<4x8x16xf32>
393  return %0 : vector<4x8x16xf32>
394}
395// CHECK-LABEL: llvm.func @insert_element_into_vec_3d
396//       CHECK:   llvm.extractvalue {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]">
397//       CHECK:   llvm.mlir.constant(15 : i64) : !llvm.i64
398//       CHECK:   llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<16 x float>">
399//       CHECK:   llvm.insertvalue {{.*}}, {{.*}}[3, 7] : !llvm<"[4 x [8 x <16 x float>]]">
400//       CHECK:   llvm.return {{.*}} : !llvm<"[4 x [8 x <16 x float>]]">
401
402func @vector_type_cast(%arg0: memref<8x8x8xf32>) -> memref<vector<8x8x8xf32>> {
403  %0 = vector.type_cast %arg0: memref<8x8x8xf32> to memref<vector<8x8x8xf32>>
404  return %0 : memref<vector<8x8x8xf32>>
405}
406// CHECK-LABEL: llvm.func @vector_type_cast
407//       CHECK:   llvm.mlir.undef : !llvm<"{ [8 x [8 x <8 x float>]]*, [8 x [8 x <8 x float>]]*, i64 }">
408//       CHECK:   %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
409//       CHECK:   %[[allocatedBit:.*]] = llvm.bitcast %[[allocated]] : !llvm<"float*"> to !llvm<"[8 x [8 x <8 x float>]]*">
410//       CHECK:   llvm.insertvalue %[[allocatedBit]], {{.*}}[0] : !llvm<"{ [8 x [8 x <8 x float>]]*, [8 x [8 x <8 x float>]]*, i64 }">
411//       CHECK:   %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm<"{ float*, float*, i64, [3 x i64], [3 x i64] }">
412//       CHECK:   %[[alignedBit:.*]] = llvm.bitcast %[[aligned]] : !llvm<"float*"> to !llvm<"[8 x [8 x <8 x float>]]*">
413//       CHECK:   llvm.insertvalue %[[alignedBit]], {{.*}}[1] : !llvm<"{ [8 x [8 x <8 x float>]]*, [8 x [8 x <8 x float>]]*, i64 }">
414//       CHECK:   llvm.mlir.constant(0 : index
415//       CHECK:   llvm.insertvalue {{.*}}[2] : !llvm<"{ [8 x [8 x <8 x float>]]*, [8 x [8 x <8 x float>]]*, i64 }">
416
417func @vector_type_cast_non_zero_addrspace(%arg0: memref<8x8x8xf32, 3>) -> memref<vector<8x8x8xf32>, 3> {
418  %0 = vector.type_cast %arg0: memref<8x8x8xf32, 3> to memref<vector<8x8x8xf32>, 3>
419  return %0 : memref<vector<8x8x8xf32>, 3>
420}
421// CHECK-LABEL: llvm.func @vector_type_cast_non_zero_addrspace
422//       CHECK:   llvm.mlir.undef : !llvm<"{ [8 x [8 x <8 x float>]] addrspace(3)*, [8 x [8 x <8 x float>]] addrspace(3)*, i64 }">
423//       CHECK:   %[[allocated:.*]] = llvm.extractvalue {{.*}}[0] : !llvm<"{ float addrspace(3)*, float addrspace(3)*, i64, [3 x i64], [3 x i64] }">
424//       CHECK:   %[[allocatedBit:.*]] = llvm.bitcast %[[allocated]] : !llvm<"float addrspace(3)*"> to !llvm<"[8 x [8 x <8 x float>]] addrspace(3)*">
425//       CHECK:   llvm.insertvalue %[[allocatedBit]], {{.*}}[0] : !llvm<"{ [8 x [8 x <8 x float>]] addrspace(3)*, [8 x [8 x <8 x float>]] addrspace(3)*, i64 }">
426//       CHECK:   %[[aligned:.*]] = llvm.extractvalue {{.*}}[1] : !llvm<"{ float addrspace(3)*, float addrspace(3)*, i64, [3 x i64], [3 x i64] }">
427//       CHECK:   %[[alignedBit:.*]] = llvm.bitcast %[[aligned]] : !llvm<"float addrspace(3)*"> to !llvm<"[8 x [8 x <8 x float>]] addrspace(3)*">
428//       CHECK:   llvm.insertvalue %[[alignedBit]], {{.*}}[1] : !llvm<"{ [8 x [8 x <8 x float>]] addrspace(3)*, [8 x [8 x <8 x float>]] addrspace(3)*, i64 }">
429//       CHECK:   llvm.mlir.constant(0 : index
430//       CHECK:   llvm.insertvalue {{.*}}[2] : !llvm<"{ [8 x [8 x <8 x float>]] addrspace(3)*, [8 x [8 x <8 x float>]] addrspace(3)*, i64 }">
431
432func @vector_print_scalar_i1(%arg0: i1) {
433  vector.print %arg0 : i1
434  return
435}
436// CHECK-LABEL: llvm.func @vector_print_scalar_i1(
437// CHECK-SAME: %[[A:.*]]: !llvm.i1)
438//       CHECK: %[[T:.*]] = llvm.mlir.constant(1 : i32) : !llvm.i32
439//       CHECK: %[[F:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
440//       CHECK: %[[S:.*]] = llvm.select %[[A]], %[[T]], %[[F]] : !llvm.i1, !llvm.i32
441//       CHECK: llvm.call @print_i32(%[[S]]) : (!llvm.i32) -> ()
442//       CHECK: llvm.call @print_newline() : () -> ()
443
444func @vector_print_scalar_i32(%arg0: i32) {
445  vector.print %arg0 : i32
446  return
447}
448// CHECK-LABEL: llvm.func @vector_print_scalar_i32(
449// CHECK-SAME: %[[A:.*]]: !llvm.i32)
450//       CHECK:    llvm.call @print_i32(%[[A]]) : (!llvm.i32) -> ()
451//       CHECK:    llvm.call @print_newline() : () -> ()
452
453func @vector_print_scalar_i64(%arg0: i64) {
454  vector.print %arg0 : i64
455  return
456}
457// CHECK-LABEL: llvm.func @vector_print_scalar_i64(
458// CHECK-SAME: %[[A:.*]]: !llvm.i64)
459//       CHECK:    llvm.call @print_i64(%[[A]]) : (!llvm.i64) -> ()
460//       CHECK:    llvm.call @print_newline() : () -> ()
461
462func @vector_print_scalar_f32(%arg0: f32) {
463  vector.print %arg0 : f32
464  return
465}
466// CHECK-LABEL: llvm.func @vector_print_scalar_f32(
467// CHECK-SAME: %[[A:.*]]: !llvm.float)
468//       CHECK:    llvm.call @print_f32(%[[A]]) : (!llvm.float) -> ()
469//       CHECK:    llvm.call @print_newline() : () -> ()
470
471func @vector_print_scalar_f64(%arg0: f64) {
472  vector.print %arg0 : f64
473  return
474}
475// CHECK-LABEL: llvm.func @vector_print_scalar_f64(
476// CHECK-SAME: %[[A:.*]]: !llvm.double)
477//       CHECK:    llvm.call @print_f64(%[[A]]) : (!llvm.double) -> ()
478//       CHECK:    llvm.call @print_newline() : () -> ()
479
480func @vector_print_vector(%arg0: vector<2x2xf32>) {
481  vector.print %arg0 : vector<2x2xf32>
482  return
483}
484// CHECK-LABEL: llvm.func @vector_print_vector(
485// CHECK-SAME: %[[A:.*]]: !llvm<"[2 x <2 x float>]">)
486//       CHECK:    llvm.call @print_open() : () -> ()
487//       CHECK:    %[[x0:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[2 x <2 x float>]">
488//       CHECK:    llvm.call @print_open() : () -> ()
489//       CHECK:    %[[x1:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
490//       CHECK:    %[[x2:.*]] = llvm.extractelement %[[x0]][%[[x1]] : !llvm.i64] : !llvm<"<2 x float>">
491//       CHECK:    llvm.call @print_f32(%[[x2]]) : (!llvm.float) -> ()
492//       CHECK:    llvm.call @print_comma() : () -> ()
493//       CHECK:    %[[x3:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
494//       CHECK:    %[[x4:.*]] = llvm.extractelement %[[x0]][%[[x3]] : !llvm.i64] : !llvm<"<2 x float>">
495//       CHECK:    llvm.call @print_f32(%[[x4]]) : (!llvm.float) -> ()
496//       CHECK:    llvm.call @print_close() : () -> ()
497//       CHECK:    llvm.call @print_comma() : () -> ()
498//       CHECK:    %[[x5:.*]] = llvm.extractvalue %[[A]][1] : !llvm<"[2 x <2 x float>]">
499//       CHECK:    llvm.call @print_open() : () -> ()
500//       CHECK:    %[[x6:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
501//       CHECK:    %[[x7:.*]] = llvm.extractelement %[[x5]][%[[x6]] : !llvm.i64] : !llvm<"<2 x float>">
502//       CHECK:    llvm.call @print_f32(%[[x7]]) : (!llvm.float) -> ()
503//       CHECK:    llvm.call @print_comma() : () -> ()
504//       CHECK:    %[[x8:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
505//       CHECK:    %[[x9:.*]] = llvm.extractelement %[[x5]][%[[x8]] : !llvm.i64] : !llvm<"<2 x float>">
506//       CHECK:    llvm.call @print_f32(%[[x9]]) : (!llvm.float) -> ()
507//       CHECK:    llvm.call @print_close() : () -> ()
508//       CHECK:    llvm.call @print_close() : () -> ()
509//       CHECK:    llvm.call @print_newline() : () -> ()
510
511func @extract_strided_slice1(%arg0: vector<4xf32>) -> vector<2xf32> {
512  %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4xf32> to vector<2xf32>
513  return %0 : vector<2xf32>
514}
515// CHECK-LABEL: llvm.func @extract_strided_slice1
516//       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
517//       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2xf32>) : !llvm<"<2 x float>">
518//       CHECK:    llvm.mlir.constant(2 : index) : !llvm.i64
519//       CHECK:    llvm.extractelement %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
520//       CHECK:    llvm.mlir.constant(0 : index) : !llvm.i64
521//       CHECK:    llvm.insertelement %{{.*}}, %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
522//       CHECK:    llvm.mlir.constant(3 : index) : !llvm.i64
523//       CHECK:    llvm.extractelement %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
524//       CHECK:    llvm.mlir.constant(1 : index) : !llvm.i64
525//       CHECK:    llvm.insertelement %{{.*}}, %{{.*}}[%{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
526
527func @extract_strided_slice2(%arg0: vector<4x8xf32>) -> vector<2x8xf32> {
528  %0 = vector.extract_strided_slice %arg0 {offsets = [2], sizes = [2], strides = [1]} : vector<4x8xf32> to vector<2x8xf32>
529  return %0 : vector<2x8xf32>
530}
531// CHECK-LABEL: llvm.func @extract_strided_slice2
532//       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
533//       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2x8xf32>) : !llvm<"[2 x <8 x float>]">
534//       CHECK:    llvm.extractvalue %{{.*}}[2] : !llvm<"[4 x <8 x float>]">
535//       CHECK:    llvm.insertvalue %{{.*}}, %{{.*}}[0] : !llvm<"[2 x <8 x float>]">
536//       CHECK:    llvm.extractvalue %{{.*}}[3] : !llvm<"[4 x <8 x float>]">
537//       CHECK:    llvm.insertvalue %{{.*}}, %{{.*}}[1] : !llvm<"[2 x <8 x float>]">
538
539func @extract_strided_slice3(%arg0: vector<4x8xf32>) -> vector<2x2xf32> {
540  %0 = vector.extract_strided_slice %arg0 {offsets = [2, 2], sizes = [2, 2], strides = [1, 1]} : vector<4x8xf32> to vector<2x2xf32>
541  return %0 : vector<2x2xf32>
542}
543// CHECK-LABEL: llvm.func @extract_strided_slice3
544//       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
545//       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2x2xf32>) : !llvm<"[2 x <2 x float>]">
546//
547// Subvector vector<8xf32> @2
548//       CHECK:    llvm.extractvalue {{.*}}[2] : !llvm<"[4 x <8 x float>]">
549//       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
550//       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2xf32>) : !llvm<"<2 x float>">
551//       CHECK:    llvm.mlir.constant(2 : index) : !llvm.i64
552//       CHECK:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>">
553//       CHECK:    llvm.mlir.constant(0 : index) : !llvm.i64
554//       CHECK:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
555//       CHECK:    llvm.mlir.constant(3 : index) : !llvm.i64
556//       CHECK:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>">
557//       CHECK:    llvm.mlir.constant(1 : index) : !llvm.i64
558//       CHECK:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
559//       CHECK:    llvm.insertvalue {{.*}}, {{.*}}[0] : !llvm<"[2 x <2 x float>]">
560//
561// Subvector vector<8xf32> @3
562//       CHECK:    llvm.extractvalue {{.*}}[3] : !llvm<"[4 x <8 x float>]">
563//       CHECK:    llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
564//       CHECK:    llvm.mlir.constant(dense<0.000000e+00> : vector<2xf32>) : !llvm<"<2 x float>">
565//       CHECK:    llvm.mlir.constant(2 : index) : !llvm.i64
566//       CHECK:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>">
567//       CHECK:    llvm.mlir.constant(0 : index) : !llvm.i64
568//       CHECK:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
569//       CHECK:    llvm.mlir.constant(3 : index) : !llvm.i64
570//       CHECK:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<8 x float>">
571//       CHECK:    llvm.mlir.constant(1 : index) : !llvm.i64
572//       CHECK:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
573//       CHECK:    llvm.insertvalue {{.*}}, {{.*}}[1] : !llvm<"[2 x <2 x float>]">
574
575func @insert_strided_slice1(%b: vector<4x4xf32>, %c: vector<4x4x4xf32>) -> vector<4x4x4xf32> {
576  %0 = vector.insert_strided_slice %b, %c {offsets = [2, 0, 0], strides = [1, 1]} : vector<4x4xf32> into vector<4x4x4xf32>
577  return %0 : vector<4x4x4xf32>
578}
579// CHECK-LABEL: llvm.func @insert_strided_slice1
580//       CHECK:    llvm.extractvalue {{.*}}[2] : !llvm<"[4 x [4 x <4 x float>]]">
581//  CHECK-NEXT:    llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm<"[4 x [4 x <4 x float>]]">
582
583func @insert_strided_slice2(%a: vector<2x2xf32>, %b: vector<4x4xf32>) -> vector<4x4xf32> {
584  %0 = vector.insert_strided_slice %a, %b {offsets = [2, 2], strides = [1, 1]} : vector<2x2xf32> into vector<4x4xf32>
585  return %0 : vector<4x4xf32>
586}
587// CHECK-LABEL: llvm.func @insert_strided_slice2
588//
589// Subvector vector<2xf32> @0 into vector<4xf32> @2
590//       CHECK:    llvm.extractvalue {{.*}}[0] : !llvm<"[2 x <2 x float>]">
591//  CHECK-NEXT:    llvm.extractvalue {{.*}}[2] : !llvm<"[4 x <4 x float>]">
592// Element @0 -> element @2
593//  CHECK-NEXT:    llvm.mlir.constant(0 : index) : !llvm.i64
594//  CHECK-NEXT:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
595//  CHECK-NEXT:    llvm.mlir.constant(2 : index) : !llvm.i64
596//  CHECK-NEXT:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
597// Element @1 -> element @3
598//  CHECK-NEXT:    llvm.mlir.constant(1 : index) : !llvm.i64
599//  CHECK-NEXT:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
600//  CHECK-NEXT:    llvm.mlir.constant(3 : index) : !llvm.i64
601//  CHECK-NEXT:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
602//  CHECK-NEXT:    llvm.insertvalue {{.*}}, {{.*}}[2] : !llvm<"[4 x <4 x float>]">
603//
604// Subvector vector<2xf32> @1 into vector<4xf32> @3
605//       CHECK:    llvm.extractvalue {{.*}}[1] : !llvm<"[2 x <2 x float>]">
606//  CHECK-NEXT:    llvm.extractvalue {{.*}}[3] : !llvm<"[4 x <4 x float>]">
607// Element @0 -> element @2
608//  CHECK-NEXT:    llvm.mlir.constant(0 : index) : !llvm.i64
609//  CHECK-NEXT:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
610//  CHECK-NEXT:    llvm.mlir.constant(2 : index) : !llvm.i64
611//  CHECK-NEXT:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
612// Element @1 -> element @3
613//  CHECK-NEXT:    llvm.mlir.constant(1 : index) : !llvm.i64
614//  CHECK-NEXT:    llvm.extractelement {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<2 x float>">
615//  CHECK-NEXT:    llvm.mlir.constant(3 : index) : !llvm.i64
616//  CHECK-NEXT:    llvm.insertelement {{.*}}, {{.*}}[{{.*}} : !llvm.i64] : !llvm<"<4 x float>">
617//  CHECK-NEXT:    llvm.insertvalue {{.*}}, {{.*}}[3] : !llvm<"[4 x <4 x float>]">
618
619func @insert_strided_slice3(%arg0: vector<2x4xf32>, %arg1: vector<16x4x8xf32>) -> vector<16x4x8xf32> {
620  %0 = vector.insert_strided_slice %arg0, %arg1 {offsets = [0, 0, 2], strides = [1, 1]}:
621        vector<2x4xf32> into vector<16x4x8xf32>
622  return %0 : vector<16x4x8xf32>
623}
624// CHECK-LABEL: llvm.func @insert_strided_slice3(
625// CHECK-SAME: %[[A:.*]]: !llvm<"[2 x <4 x float>]">,
626// CHECK-SAME: %[[B:.*]]: !llvm<"[16 x [4 x <8 x float>]]">)
627//      CHECK: %[[s0:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[16 x [4 x <8 x float>]]">
628//      CHECK: %[[s1:.*]] = llvm.extractvalue %[[A]][0] : !llvm<"[2 x <4 x float>]">
629//      CHECK: %[[s2:.*]] = llvm.extractvalue %[[B]][0, 0] : !llvm<"[16 x [4 x <8 x float>]]">
630//      CHECK: %[[s3:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
631//      CHECK: %[[s4:.*]] = llvm.extractelement %[[s1]][%[[s3]] : !llvm.i64] : !llvm<"<4 x float>">
632//      CHECK: %[[s5:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64
633//      CHECK: %[[s6:.*]] = llvm.insertelement %[[s4]], %[[s2]][%[[s5]] : !llvm.i64] : !llvm<"<8 x float>">
634//      CHECK: %[[s7:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
635//      CHECK: %[[s8:.*]] = llvm.extractelement %[[s1]][%[[s7]] : !llvm.i64] : !llvm<"<4 x float>">
636//      CHECK: %[[s9:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64
637//      CHECK: %[[s10:.*]] = llvm.insertelement %[[s8]], %[[s6]][%[[s9]] : !llvm.i64] : !llvm<"<8 x float>">
638//      CHECK: %[[s11:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64
639//      CHECK: %[[s12:.*]] = llvm.extractelement %[[s1]][%[[s11]] : !llvm.i64] : !llvm<"<4 x float>">
640//      CHECK: %[[s13:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64
641//      CHECK: %[[s14:.*]] = llvm.insertelement %[[s12]], %[[s10]][%[[s13]] : !llvm.i64] : !llvm<"<8 x float>">
642//      CHECK: %[[s15:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64
643//      CHECK: %[[s16:.*]] = llvm.extractelement %[[s1]][%[[s15]] : !llvm.i64] : !llvm<"<4 x float>">
644//      CHECK: %[[s17:.*]] = llvm.mlir.constant(5 : index) : !llvm.i64
645//      CHECK: %[[s18:.*]] = llvm.insertelement %[[s16]], %[[s14]][%[[s17]] : !llvm.i64] : !llvm<"<8 x float>">
646//      CHECK: %[[s19:.*]] = llvm.insertvalue %[[s18]], %[[s0]][0] : !llvm<"[4 x <8 x float>]">
647//      CHECK: %[[s20:.*]] = llvm.extractvalue %[[A]][1] : !llvm<"[2 x <4 x float>]">
648//      CHECK: %[[s21:.*]] = llvm.extractvalue %[[B]][0, 1] : !llvm<"[16 x [4 x <8 x float>]]">
649//      CHECK: %[[s22:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
650//      CHECK: %[[s23:.*]] = llvm.extractelement %[[s20]][%[[s22]] : !llvm.i64] : !llvm<"<4 x float>">
651//      CHECK: %[[s24:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64
652//      CHECK: %[[s25:.*]] = llvm.insertelement %[[s23]], %[[s21]][%[[s24]] : !llvm.i64] : !llvm<"<8 x float>">
653//      CHECK: %[[s26:.*]] = llvm.mlir.constant(1 : index) : !llvm.i64
654//      CHECK: %[[s27:.*]] = llvm.extractelement %[[s20]][%[[s26]] : !llvm.i64] : !llvm<"<4 x float>">
655//      CHECK: %[[s28:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64
656//      CHECK: %[[s29:.*]] = llvm.insertelement %[[s27]], %[[s25]][%[[s28]] : !llvm.i64] : !llvm<"<8 x float>">
657//      CHECK: %[[s30:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64
658//      CHECK: %[[s31:.*]] = llvm.extractelement %[[s20]][%[[s30]] : !llvm.i64] : !llvm<"<4 x float>">
659//      CHECK: %[[s32:.*]] = llvm.mlir.constant(4 : index) : !llvm.i64
660//      CHECK: %[[s33:.*]] = llvm.insertelement %[[s31]], %[[s29]][%[[s32]] : !llvm.i64] : !llvm<"<8 x float>">
661//      CHECK: %[[s34:.*]] = llvm.mlir.constant(3 : index) : !llvm.i64
662//      CHECK: %[[s35:.*]] = llvm.extractelement %[[s20]][%[[s34]] : !llvm.i64] : !llvm<"<4 x float>">
663//      CHECK: %[[s36:.*]] = llvm.mlir.constant(5 : index) : !llvm.i64
664//      CHECK: %[[s37:.*]] = llvm.insertelement %[[s35]], %[[s33]][%[[s36]] : !llvm.i64] : !llvm<"<8 x float>">
665//      CHECK: %[[s38:.*]] = llvm.insertvalue %[[s37]], %[[s19]][1] : !llvm<"[4 x <8 x float>]">
666//      CHECK: %[[s39:.*]] = llvm.insertvalue %[[s38]], %[[B]][0] : !llvm<"[16 x [4 x <8 x float>]]">
667//      CHECK: llvm.return %[[s39]] : !llvm<"[16 x [4 x <8 x float>]]">
668
669func @extract_strides(%arg0: vector<3x3xf32>) -> vector<1x1xf32> {
670  %0 = vector.extract_slices %arg0, [2, 2], [1, 1]
671    : vector<3x3xf32> into tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>>
672  %1 = vector.tuple_get %0, 3 : tuple<vector<2x2xf32>, vector<2x1xf32>, vector<1x2xf32>, vector<1x1xf32>>
673  return %1 : vector<1x1xf32>
674}
675// CHECK-LABEL: llvm.func @extract_strides(
676// CHECK-SAME: %[[A:.*]]: !llvm<"[3 x <3 x float>]">)
677//      CHECK: %[[s0:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<1x1xf32>) : !llvm<"[1 x <1 x float>]">
678//      CHECK: %[[s1:.*]] = llvm.extractvalue %[[A]][2] : !llvm<"[3 x <3 x float>]">
679//      CHECK: %[[s3:.*]] = llvm.mlir.constant(dense<0.000000e+00> : vector<1xf32>) : !llvm<"<1 x float>">
680//      CHECK: %[[s4:.*]] = llvm.mlir.constant(2 : index) : !llvm.i64
681//      CHECK: %[[s5:.*]] = llvm.extractelement %[[s1]][%[[s4]] : !llvm.i64] : !llvm<"<3 x float>">
682//      CHECK: %[[s6:.*]] = llvm.mlir.constant(0 : index) : !llvm.i64
683//      CHECK: %[[s7:.*]] = llvm.insertelement %[[s5]], %[[s3]][%[[s6]] : !llvm.i64] : !llvm<"<1 x float>">
684//      CHECK: %[[s8:.*]] = llvm.insertvalue %[[s7]], %[[s0]][0] : !llvm<"[1 x <1 x float>]">
685//      CHECK: llvm.return %[[s8]] : !llvm<"[1 x <1 x float>]">
686
687// CHECK-LABEL: llvm.func @vector_fma(
688//  CHECK-SAME: %[[A:.*]]: !llvm<"<8 x float>">, %[[B:.*]]: !llvm<"[2 x <4 x float>]">)
689//  CHECK-SAME: -> !llvm<"{ <8 x float>, [2 x <4 x float>] }"> {
690func @vector_fma(%a: vector<8xf32>, %b: vector<2x4xf32>) -> (vector<8xf32>, vector<2x4xf32>) {
691  //         CHECK: "llvm.intr.fmuladd"(%[[A]], %[[A]], %[[A]]) :
692  //    CHECK-SAME:   (!llvm<"<8 x float>">, !llvm<"<8 x float>">, !llvm<"<8 x float>">) -> !llvm<"<8 x float>">
693  %0 = vector.fma %a, %a, %a : vector<8xf32>
694
695  //       CHECK: %[[b00:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[2 x <4 x float>]">
696  //       CHECK: %[[b01:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[2 x <4 x float>]">
697  //       CHECK: %[[b02:.*]] = llvm.extractvalue %[[B]][0] : !llvm<"[2 x <4 x float>]">
698  //       CHECK: %[[B0:.*]] = "llvm.intr.fmuladd"(%[[b00]], %[[b01]], %[[b02]]) :
699  //  CHECK-SAME: (!llvm<"<4 x float>">, !llvm<"<4 x float>">, !llvm<"<4 x float>">) -> !llvm<"<4 x float>">
700  //       CHECK: llvm.insertvalue %[[B0]], {{.*}}[0] : !llvm<"[2 x <4 x float>]">
701  //       CHECK: %[[b10:.*]] = llvm.extractvalue %[[B]][1] : !llvm<"[2 x <4 x float>]">
702  //       CHECK: %[[b11:.*]] = llvm.extractvalue %[[B]][1] : !llvm<"[2 x <4 x float>]">
703  //       CHECK: %[[b12:.*]] = llvm.extractvalue %[[B]][1] : !llvm<"[2 x <4 x float>]">
704  //       CHECK: %[[B1:.*]] = "llvm.intr.fmuladd"(%[[b10]], %[[b11]], %[[b12]]) :
705  //  CHECK-SAME: (!llvm<"<4 x float>">, !llvm<"<4 x float>">, !llvm<"<4 x float>">) -> !llvm<"<4 x float>">
706  //       CHECK: llvm.insertvalue %[[B1]], {{.*}}[1] : !llvm<"[2 x <4 x float>]">
707  %1 = vector.fma %b, %b, %b : vector<2x4xf32>
708
709  return %0, %1: vector<8xf32>, vector<2x4xf32>
710}
711
712func @reduce_f32(%arg0: vector<16xf32>) -> f32 {
713  %0 = vector.reduction "add", %arg0 : vector<16xf32> into f32
714  return %0 : f32
715}
716// CHECK-LABEL: llvm.func @reduce_f32(
717// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x float>">)
718//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f32) : !llvm.float
719//      CHECK: %[[V:.*]] = "llvm.intr.experimental.vector.reduce.v2.fadd"(%[[C]], %[[A]])
720// CHECK-SAME: {reassoc = false} : (!llvm.float, !llvm<"<16 x float>">) -> !llvm.float
721//      CHECK: llvm.return %[[V]] : !llvm.float
722
723func @reduce_f64(%arg0: vector<16xf64>) -> f64 {
724  %0 = vector.reduction "add", %arg0 : vector<16xf64> into f64
725  return %0 : f64
726}
727// CHECK-LABEL: llvm.func @reduce_f64(
728// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x double>">)
729//      CHECK: %[[C:.*]] = llvm.mlir.constant(0.000000e+00 : f64) : !llvm.double
730//      CHECK: %[[V:.*]] = "llvm.intr.experimental.vector.reduce.v2.fadd"(%[[C]], %[[A]])
731// CHECK-SAME: {reassoc = false} : (!llvm.double, !llvm<"<16 x double>">) -> !llvm.double
732//      CHECK: llvm.return %[[V]] : !llvm.double
733
734func @reduce_i32(%arg0: vector<16xi32>) -> i32 {
735  %0 = vector.reduction "add", %arg0 : vector<16xi32> into i32
736  return %0 : i32
737}
738// CHECK-LABEL: llvm.func @reduce_i32(
739// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x i32>">)
740//      CHECK: %[[V:.*]] = "llvm.intr.experimental.vector.reduce.add"(%[[A]])
741//      CHECK: llvm.return %[[V]] : !llvm.i32
742
743func @reduce_i64(%arg0: vector<16xi64>) -> i64 {
744  %0 = vector.reduction "add", %arg0 : vector<16xi64> into i64
745  return %0 : i64
746}
747// CHECK-LABEL: llvm.func @reduce_i64(
748// CHECK-SAME: %[[A:.*]]: !llvm<"<16 x i64>">)
749//      CHECK: %[[V:.*]] = "llvm.intr.experimental.vector.reduce.add"(%[[A]])
750//      CHECK: llvm.return %[[V]] : !llvm.i64
751
752
753//                          4x16                16x3               4x3
754func @matrix_ops(%A: vector<64xf64>, %B: vector<48xf64>) -> vector<12xf64> {
755  %C = vector.matrix_multiply %A, %B
756    { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32 } :
757    (vector<64xf64>, vector<48xf64>) -> vector<12xf64>
758  return %C: vector<12xf64>
759}
760// CHECK-LABEL: llvm.func @matrix_ops
761//       CHECK:   llvm.intr.matrix.multiply %{{.*}}, %{{.*}} {
762//  CHECK-SAME: lhs_columns = 16 : i32, lhs_rows = 4 : i32, rhs_columns = 3 : i32
763//  CHECK-SAME: } : (!llvm<"<64 x double>">, !llvm<"<48 x double>">) -> !llvm<"<12 x double>">
764
765func @transfer_read_1d(%A : memref<?xf32>, %base: index) -> vector<17xf32> {
766  %f7 = constant 7.0: f32
767  %f = vector.transfer_read %A[%base], %f7
768      {permutation_map = affine_map<(d0) -> (d0)>} :
769    memref<?xf32>, vector<17xf32>
770  vector.transfer_write %f, %A[%base]
771      {permutation_map = affine_map<(d0) -> (d0)>} :
772    vector<17xf32>, memref<?xf32>
773  return %f: vector<17xf32>
774}
775// CHECK-LABEL: func @transfer_read_1d
776//  CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm<"<17 x float>">
777//
778// 1. Bitcast to vector form.
779//       CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
780//  CHECK-SAME: (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
781//       CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] :
782//  CHECK-SAME: !llvm<"float*"> to !llvm<"<17 x float>*">
783//
784// 2. Create a vector with linear indices [ 0 .. vector_length - 1 ].
785//       CHECK: %[[linearIndex:.*]] = llvm.mlir.constant(
786//  CHECK-SAME: dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> :
787//  CHECK-SAME: vector<17xi64>) : !llvm<"<17 x i64>">
788//
789// 3. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].
790//       CHECK: %[[offsetVec:.*]] = llvm.mlir.undef : !llvm<"<17 x i64>">
791//       CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
792//       CHECK: %[[offsetVec2:.*]] = llvm.insertelement %[[BASE]], %[[offsetVec]][%[[c0]] :
793//  CHECK-SAME: !llvm.i32] : !llvm<"<17 x i64>">
794//       CHECK: %[[offsetVec3:.*]] = llvm.shufflevector %[[offsetVec2]], %{{.*}} [
795//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
796//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
797//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32] :
798//  CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>">
799//       CHECK: %[[offsetVec4:.*]] = llvm.add %[[offsetVec3]], %[[linearIndex]] :
800//  CHECK-SAME: !llvm<"<17 x i64>">
801//
802// 4. Let dim the memref dimension, compute the vector comparison mask:
803//    [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ]
804//       CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 0] :
805//  CHECK-SAME: !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">
806//       CHECK: %[[dimVec:.*]] = llvm.mlir.undef : !llvm<"<17 x i64>">
807//       CHECK: %[[c01:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
808//       CHECK: %[[dimVec2:.*]] = llvm.insertelement %[[DIM]], %[[dimVec]][%[[c01]] :
809//  CHECK-SAME:  !llvm.i32] : !llvm<"<17 x i64>">
810//       CHECK: %[[dimVec3:.*]] = llvm.shufflevector %[[dimVec2]], %{{.*}} [
811//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
812//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
813//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32] :
814//  CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>">
815//       CHECK: %[[mask:.*]] = llvm.icmp "slt" %[[offsetVec4]], %[[dimVec3]] :
816//  CHECK-SAME: !llvm<"<17 x i64>">
817//
818// 5. Rewrite as a masked read.
819//       CHECK: %[[PASS_THROUGH:.*]] =  llvm.mlir.constant(dense<7.000000e+00> :
820//  CHECK-SAME:  vector<17xf32>) : !llvm<"<17 x float>">
821//       CHECK: %[[loaded:.*]] = llvm.intr.masked.load %[[vecPtr]], %[[mask]],
822//  CHECK-SAME: %[[PASS_THROUGH]] {alignment = 4 : i32} :
823//  CHECK-SAME: (!llvm<"<17 x float>*">, !llvm<"<17 x i1>">, !llvm<"<17 x float>">) -> !llvm<"<17 x float>">
824
825//
826// 1. Bitcast to vector form.
827//       CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} :
828//  CHECK-SAME: (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
829//       CHECK: %[[vecPtr_b:.*]] = llvm.bitcast %[[gep_b]] :
830//  CHECK-SAME: !llvm<"float*"> to !llvm<"<17 x float>*">
831//
832// 2. Create a vector with linear indices [ 0 .. vector_length - 1 ].
833//       CHECK: %[[linearIndex_b:.*]] = llvm.mlir.constant(
834//  CHECK-SAME: dense<[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]> :
835//  CHECK-SAME:  vector<17xi64>) : !llvm<"<17 x i64>">
836//
837// 3. Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].
838//       CHECK: llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32, 0 : i32,
839//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
840//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32] :
841//  CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>">
842//       CHECK: llvm.add
843//
844// 4. Let dim the memref dimension, compute the vector comparison mask:
845//    [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ]
846//       CHECK: llvm.shufflevector {{.*}} [0 : i32, 0 : i32, 0 : i32, 0 : i32,
847//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
848//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32] :
849//  CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>">
850//       CHECK: %[[mask_b:.*]] = llvm.icmp "slt" {{.*}} : !llvm<"<17 x i64>">
851//
852// 5. Rewrite as a masked write.
853//       CHECK: llvm.intr.masked.store %[[loaded]], %[[vecPtr_b]], %[[mask_b]]
854//  CHECK-SAME: {alignment = 4 : i32} :
855//  CHECK-SAME: !llvm<"<17 x float>">, !llvm<"<17 x i1>"> into !llvm<"<17 x float>*">
856
857func @transfer_read_2d_to_1d(%A : memref<?x?xf32>, %base0: index, %base1: index) -> vector<17xf32> {
858  %f7 = constant 7.0: f32
859  %f = vector.transfer_read %A[%base0, %base1], %f7
860      {permutation_map = affine_map<(d0, d1) -> (d1)>} :
861    memref<?x?xf32>, vector<17xf32>
862  return %f: vector<17xf32>
863}
864// CHECK-LABEL: func @transfer_read_2d_to_1d
865//  CHECK-SAME: %[[BASE_0:[a-zA-Z0-9]*]]: !llvm.i64, %[[BASE_1:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm<"<17 x float>">
866//
867// Create offsetVector = [ offset + 0 .. offset + vector_length - 1 ].
868//       CHECK: %[[offsetVec:.*]] = llvm.mlir.undef : !llvm<"<17 x i64>">
869//       CHECK: %[[c0:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
870// Here we check we properly use %BASE_1
871//       CHECK: %[[offsetVec2:.*]] = llvm.insertelement %[[BASE_1]], %[[offsetVec]][%[[c0]] :
872//  CHECK-SAME: !llvm.i32] : !llvm<"<17 x i64>">
873//       CHECK: %[[offsetVec3:.*]] = llvm.shufflevector %[[offsetVec2]], %{{.*}} [
874//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
875//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
876//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32] :
877//
878// Let dim the memref dimension, compute the vector comparison mask:
879//    [ offset + 0 .. offset + vector_length - 1 ] < [ dim .. dim ]
880// Here we check we properly use %DIM[1]
881//       CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 1] :
882//  CHECK-SAME: !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">
883//       CHECK: %[[dimVec:.*]] = llvm.mlir.undef : !llvm<"<17 x i64>">
884//       CHECK: %[[c01:.*]] = llvm.mlir.constant(0 : i32) : !llvm.i32
885//       CHECK: %[[dimVec2:.*]] = llvm.insertelement %[[DIM]], %[[dimVec]][%[[c01]] :
886//  CHECK-SAME:  !llvm.i32] : !llvm<"<17 x i64>">
887//       CHECK: %[[dimVec3:.*]] = llvm.shufflevector %[[dimVec2]], %{{.*}} [
888//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
889//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32, 0 : i32,
890//  CHECK-SAME:  0 : i32, 0 : i32, 0 : i32] :
891//  CHECK-SAME: !llvm<"<17 x i64>">, !llvm<"<17 x i64>">
892
893func @transfer_read_1d_non_zero_addrspace(%A : memref<?xf32, 3>, %base: index) -> vector<17xf32> {
894  %f7 = constant 7.0: f32
895  %f = vector.transfer_read %A[%base], %f7
896      {permutation_map = affine_map<(d0) -> (d0)>} :
897    memref<?xf32, 3>, vector<17xf32>
898  vector.transfer_write %f, %A[%base]
899      {permutation_map = affine_map<(d0) -> (d0)>} :
900    vector<17xf32>, memref<?xf32, 3>
901  return %f: vector<17xf32>
902}
903// CHECK-LABEL: func @transfer_read_1d_non_zero_addrspace
904//  CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm<"<17 x float>">
905//
906// 1. Check address space for GEP is correct.
907//       CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
908//  CHECK-SAME: (!llvm<"float addrspace(3)*">, !llvm.i64) -> !llvm<"float addrspace(3)*">
909//       CHECK: %[[vecPtr:.*]] = llvm.addrspacecast %[[gep]] :
910//  CHECK-SAME: !llvm<"float addrspace(3)*"> to !llvm<"<17 x float>*">
911//
912// 2. Check address space of the memref is correct.
913//       CHECK: %[[DIM:.*]] = llvm.extractvalue %{{.*}}[3, 0] :
914//  CHECK-SAME: !llvm<"{ float addrspace(3)*, float addrspace(3)*, i64, [1 x i64], [1 x i64] }">
915//
916// 3. Check address apce for GEP is correct.
917//       CHECK: %[[gep_b:.*]] = llvm.getelementptr {{.*}} :
918//  CHECK-SAME: (!llvm<"float addrspace(3)*">, !llvm.i64) -> !llvm<"float addrspace(3)*">
919//       CHECK: %[[vecPtr_b:.*]] = llvm.addrspacecast %[[gep_b]] :
920//  CHECK-SAME: !llvm<"float addrspace(3)*"> to !llvm<"<17 x float>*">
921
922func @transfer_read_1d_not_masked(%A : memref<?xf32>, %base: index) -> vector<17xf32> {
923  %f7 = constant 7.0: f32
924  %f = vector.transfer_read %A[%base], %f7 {masked = [false]} :
925    memref<?xf32>, vector<17xf32>
926  return %f: vector<17xf32>
927}
928// CHECK-LABEL: func @transfer_read_1d_not_masked
929//  CHECK-SAME: %[[BASE:[a-zA-Z0-9]*]]: !llvm.i64) -> !llvm<"<17 x float>">
930//
931// 1. Bitcast to vector form.
932//       CHECK: %[[gep:.*]] = llvm.getelementptr {{.*}} :
933//  CHECK-SAME: (!llvm<"float*">, !llvm.i64) -> !llvm<"float*">
934//       CHECK: %[[vecPtr:.*]] = llvm.bitcast %[[gep]] :
935//  CHECK-SAME: !llvm<"float*"> to !llvm<"<17 x float>*">
936//
937// 2. Rewrite as a load.
938//       CHECK: %[[loaded:.*]] = llvm.load %[[vecPtr]] {alignment = 4 : i64} : !llvm<"<17 x float>*">
939
940func @genbool_1d() -> vector<8xi1> {
941  %0 = vector.constant_mask [4] : vector<8xi1>
942  return %0 : vector<8xi1>
943}
944// CHECK-LABEL: func @genbool_1d
945// CHECK: %[[C1:.*]] = llvm.mlir.constant(dense<[true, true, true, true, false, false, false, false]> : vector<8xi1>) : !llvm<"<8 x i1>">
946// CHECK: llvm.return %[[C1]] : !llvm<"<8 x i1>">
947
948func @genbool_2d() -> vector<4x4xi1> {
949  %v = vector.constant_mask [2, 2] : vector<4x4xi1>
950  return %v: vector<4x4xi1>
951}
952
953// CHECK-LABEL: func @genbool_2d
954// CHECK: %[[C1:.*]] = llvm.mlir.constant(dense<[true, true, false, false]> : vector<4xi1>) : !llvm<"<4 x i1>">
955// CHECK: %[[C2:.*]] = llvm.mlir.constant(dense<false> : vector<4x4xi1>) : !llvm<"[4 x <4 x i1>]">
956// CHECK: %[[T0:.*]] = llvm.insertvalue %[[C1]], %[[C2]][0] : !llvm<"[4 x <4 x i1>]">
957// CHECK: %[[T1:.*]] = llvm.insertvalue %[[C1]], %[[T0]][1] : !llvm<"[4 x <4 x i1>]">
958// CHECK: llvm.return %[[T1]] : !llvm<"[4 x <4 x i1>]">
959
960func @flat_transpose(%arg0: vector<16xf32>) -> vector<16xf32> {
961  %0 = vector.flat_transpose %arg0 { rows = 4: i32, columns = 4: i32 }
962     : vector<16xf32> -> vector<16xf32>
963  return %0 : vector<16xf32>
964}
965
966// CHECK-LABEL: func @flat_transpose
967// CHECK-SAME:  %[[A:.*]]: !llvm<"<16 x float>">
968// CHECK:       %[[T:.*]] = llvm.intr.matrix.transpose %[[A]]
969// CHECK-SAME:      {columns = 4 : i32, rows = 4 : i32} :
970// CHECK-SAME:      !llvm<"<16 x float>"> into !llvm<"<16 x float>">
971// CHECK:       llvm.return %[[T]] : !llvm<"<16 x float>">
972