|
134
|
1 ; RUN: llc -march=amdgcn -mcpu=hawaii -verify-machineinstrs < %s | FileCheck -enable-var-scope -check-prefixes=GCN,CI,CIVI %s
|
|
|
2 ; RUN: llc -march=amdgcn -mcpu=fiji -mattr=-flat-for-global -verify-machineinstrs < %s | FileCheck -enable-var-scope -check-prefixes=GCN,VI,CIVI,GFX89 %s
|
|
|
3 ; RUN: llc -march=amdgcn -mcpu=gfx900 -mattr=-flat-for-global -verify-machineinstrs < %s | FileCheck -enable-var-scope -check-prefixes=GCN,VI,GFX89 %s
|
|
121
|
4
|
|
|
5 ; GCN-LABEL: {{^}}void_func_i1:
|
|
|
6 ; GCN: v_and_b32_e32 v0, 1, v0
|
|
|
7 ; GCN: buffer_store_byte v0, off
|
|
|
8 define void @void_func_i1(i1 %arg0) #0 {
|
|
|
9 store i1 %arg0, i1 addrspace(1)* undef
|
|
|
10 ret void
|
|
|
11 }
|
|
|
12
|
|
|
13 ; GCN-LABEL: {{^}}void_func_i1_zeroext:
|
|
|
14 ; GCN: s_waitcnt
|
|
|
15 ; GCN-NEXT: v_or_b32_e32 v0, 12, v0
|
|
|
16 ; GCN-NOT: v0
|
|
|
17 ; GCN: buffer_store_dword v0, off
|
|
|
18 define void @void_func_i1_zeroext(i1 zeroext %arg0) #0 {
|
|
|
19 %ext = zext i1 %arg0 to i32
|
|
|
20 %add = add i32 %ext, 12
|
|
|
21 store i32 %add, i32 addrspace(1)* undef
|
|
|
22 ret void
|
|
|
23 }
|
|
|
24
|
|
|
25 ; GCN-LABEL: {{^}}void_func_i1_signext:
|
|
|
26 ; GCN: s_waitcnt
|
|
134
|
27 ; GCN-NEXT: v_add_{{i|u}}32_e32 v0, {{(vcc, )?}}12, v0
|
|
121
|
28 ; GCN-NOT: v0
|
|
|
29 ; GCN: buffer_store_dword v0, off
|
|
|
30 define void @void_func_i1_signext(i1 signext %arg0) #0 {
|
|
|
31 %ext = sext i1 %arg0 to i32
|
|
|
32 %add = add i32 %ext, 12
|
|
|
33 store i32 %add, i32 addrspace(1)* undef
|
|
|
34 ret void
|
|
|
35 }
|
|
|
36
|
|
|
37 ; GCN-LABEL: {{^}}i1_arg_i1_use:
|
|
|
38 ; GCN: v_and_b32_e32 v0, 1, v0
|
|
|
39 ; GCN: v_cmp_eq_u32_e32 vcc, 1, v0
|
|
|
40 ; GCN: s_xor_b64 s{{\[[0-9]+:[0-9]+\]}}, vcc, -1
|
|
|
41 define void @i1_arg_i1_use(i1 %arg) #0 {
|
|
|
42 bb:
|
|
|
43 br i1 %arg, label %bb2, label %bb1
|
|
|
44
|
|
|
45 bb1:
|
|
|
46 store volatile i32 0, i32 addrspace(1)* undef
|
|
|
47 br label %bb2
|
|
|
48
|
|
|
49 bb2:
|
|
|
50 ret void
|
|
|
51 }
|
|
|
52
|
|
|
53 ; GCN-LABEL: {{^}}void_func_i8:
|
|
|
54 ; GCN-NOT: v0
|
|
|
55 ; GCN: buffer_store_byte v0, off
|
|
|
56 define void @void_func_i8(i8 %arg0) #0 {
|
|
|
57 store i8 %arg0, i8 addrspace(1)* undef
|
|
|
58 ret void
|
|
|
59 }
|
|
|
60
|
|
|
61 ; GCN-LABEL: {{^}}void_func_i8_zeroext:
|
|
|
62 ; GCN-NOT: and_b32
|
|
134
|
63 ; GCN: v_add_{{i|u}}32_e32 v0, {{(vcc, )?}}12, v0
|
|
121
|
64 define void @void_func_i8_zeroext(i8 zeroext %arg0) #0 {
|
|
|
65 %ext = zext i8 %arg0 to i32
|
|
|
66 %add = add i32 %ext, 12
|
|
|
67 store i32 %add, i32 addrspace(1)* undef
|
|
|
68 ret void
|
|
|
69 }
|
|
|
70
|
|
|
71 ; GCN-LABEL: {{^}}void_func_i8_signext:
|
|
|
72 ; GCN-NOT: v_bfe_i32
|
|
134
|
73 ; GCN: v_add_{{i|u}}32_e32 v0, {{(vcc, )?}}12, v0
|
|
121
|
74 define void @void_func_i8_signext(i8 signext %arg0) #0 {
|
|
|
75 %ext = sext i8 %arg0 to i32
|
|
|
76 %add = add i32 %ext, 12
|
|
|
77 store i32 %add, i32 addrspace(1)* undef
|
|
|
78 ret void
|
|
|
79 }
|
|
|
80
|
|
|
81 ; GCN-LABEL: {{^}}void_func_i16:
|
|
|
82 ; GCN: buffer_store_short v0, off
|
|
|
83 define void @void_func_i16(i16 %arg0) #0 {
|
|
|
84 store i16 %arg0, i16 addrspace(1)* undef
|
|
|
85 ret void
|
|
|
86 }
|
|
|
87
|
|
|
88 ; GCN-LABEL: {{^}}void_func_i16_zeroext:
|
|
|
89 ; GCN-NOT: v0
|
|
134
|
90 ; GCN: v_add_{{i|u}}32_e32 v0, {{(vcc, )?}}12, v0
|
|
121
|
91 define void @void_func_i16_zeroext(i16 zeroext %arg0) #0 {
|
|
|
92 %ext = zext i16 %arg0 to i32
|
|
|
93 %add = add i32 %ext, 12
|
|
|
94 store i32 %add, i32 addrspace(1)* undef
|
|
|
95 ret void
|
|
|
96 }
|
|
|
97
|
|
|
98 ; GCN-LABEL: {{^}}void_func_i16_signext:
|
|
|
99 ; GCN-NOT: v0
|
|
134
|
100 ; GCN: v_add_{{i|u}}32_e32 v0, {{(vcc, )?}}12, v0
|
|
121
|
101 define void @void_func_i16_signext(i16 signext %arg0) #0 {
|
|
|
102 %ext = sext i16 %arg0 to i32
|
|
|
103 %add = add i32 %ext, 12
|
|
|
104 store i32 %add, i32 addrspace(1)* undef
|
|
|
105 ret void
|
|
|
106 }
|
|
|
107
|
|
|
108 ; GCN-LABEL: {{^}}void_func_i32:
|
|
|
109 ; GCN-NOT: v0
|
|
|
110 ; GCN: buffer_store_dword v0, off
|
|
|
111 define void @void_func_i32(i32 %arg0) #0 {
|
|
|
112 store i32 %arg0, i32 addrspace(1)* undef
|
|
|
113 ret void
|
|
|
114 }
|
|
|
115
|
|
|
116 ; GCN-LABEL: {{^}}void_func_i64:
|
|
|
117 ; GCN-NOT: v[0:1]
|
|
|
118 ; GCN-NOT: v0
|
|
|
119 ; GCN-NOT: v1
|
|
|
120 ; GCN: buffer_store_dwordx2 v[0:1], off
|
|
|
121 define void @void_func_i64(i64 %arg0) #0 {
|
|
|
122 store i64 %arg0, i64 addrspace(1)* undef
|
|
|
123 ret void
|
|
|
124 }
|
|
|
125
|
|
|
126 ; GCN-LABEL: {{^}}void_func_f16:
|
|
|
127 ; VI-NOT: v0
|
|
|
128 ; CI: v_cvt_f16_f32_e32 v0, v0
|
|
|
129 ; GCN: buffer_store_short v0, off
|
|
|
130 define void @void_func_f16(half %arg0) #0 {
|
|
|
131 store half %arg0, half addrspace(1)* undef
|
|
|
132 ret void
|
|
|
133 }
|
|
|
134
|
|
|
135 ; GCN-LABEL: {{^}}void_func_f32
|
|
|
136 ; GCN-NOT: v0
|
|
|
137 ; GCN: buffer_store_dword v0, off
|
|
|
138 define void @void_func_f32(float %arg0) #0 {
|
|
|
139 store float %arg0, float addrspace(1)* undef
|
|
|
140 ret void
|
|
|
141 }
|
|
|
142
|
|
|
143 ; GCN-LABEL: {{^}}void_func_f64:
|
|
|
144 ; GCN-NOT: v[0:1]
|
|
|
145 ; GCN-NOT: v0
|
|
|
146 ; GCN-NOT: v1
|
|
|
147 ; GCN: buffer_store_dwordx2 v[0:1], off
|
|
|
148 define void @void_func_f64(double %arg0) #0 {
|
|
|
149 store double %arg0, double addrspace(1)* undef
|
|
|
150 ret void
|
|
|
151 }
|
|
|
152
|
|
|
153 ; GCN-LABEL: {{^}}void_func_v2i32:
|
|
|
154 ; GCN-NOT: v[0:1]
|
|
|
155 ; GCN-NOT: v0
|
|
|
156 ; GCN-NOT: v1
|
|
|
157 ; GCN: buffer_store_dwordx2 v[0:1], off
|
|
|
158 define void @void_func_v2i32(<2 x i32> %arg0) #0 {
|
|
|
159 store <2 x i32> %arg0, <2 x i32> addrspace(1)* undef
|
|
|
160 ret void
|
|
|
161 }
|
|
|
162
|
|
|
163 ; GCN-LABEL: {{^}}void_func_v3i32:
|
|
|
164 ; GCN-DAG: buffer_store_dword v2, off
|
|
|
165 ; GCN-DAG: buffer_store_dwordx2 v[0:1], off
|
|
|
166 define void @void_func_v3i32(<3 x i32> %arg0) #0 {
|
|
|
167 store <3 x i32> %arg0, <3 x i32> addrspace(1)* undef
|
|
|
168 ret void
|
|
|
169 }
|
|
|
170
|
|
|
171 ; GCN-LABEL: {{^}}void_func_v4i32:
|
|
|
172 ; GCN: buffer_store_dwordx4 v[0:3], off
|
|
|
173 define void @void_func_v4i32(<4 x i32> %arg0) #0 {
|
|
|
174 store <4 x i32> %arg0, <4 x i32> addrspace(1)* undef
|
|
|
175 ret void
|
|
|
176 }
|
|
|
177
|
|
|
178 ; GCN-LABEL: {{^}}void_func_v5i32:
|
|
|
179 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
180 ; GCN-DAG: buffer_store_dword v4, off
|
|
|
181 define void @void_func_v5i32(<5 x i32> %arg0) #0 {
|
|
|
182 store <5 x i32> %arg0, <5 x i32> addrspace(1)* undef
|
|
|
183 ret void
|
|
|
184 }
|
|
|
185
|
|
|
186 ; GCN-LABEL: {{^}}void_func_v8i32:
|
|
|
187 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
188 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
189 define void @void_func_v8i32(<8 x i32> %arg0) #0 {
|
|
|
190 store <8 x i32> %arg0, <8 x i32> addrspace(1)* undef
|
|
|
191 ret void
|
|
|
192 }
|
|
|
193
|
|
|
194 ; GCN-LABEL: {{^}}void_func_v16i32:
|
|
|
195 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
196 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
197 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
198 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
199 define void @void_func_v16i32(<16 x i32> %arg0) #0 {
|
|
|
200 store <16 x i32> %arg0, <16 x i32> addrspace(1)* undef
|
|
|
201 ret void
|
|
|
202 }
|
|
|
203
|
|
|
204 ; GCN-LABEL: {{^}}void_func_v32i32:
|
|
|
205 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
206 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
207 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
208 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
209 ; GCN-DAG: buffer_store_dwordx4 v[16:19], off
|
|
|
210 ; GCN-DAG: buffer_store_dwordx4 v[20:23], off
|
|
|
211 ; GCN-DAG: buffer_store_dwordx4 v[24:27], off
|
|
|
212 ; GCN-DAG: buffer_store_dwordx4 v[28:31], off
|
|
|
213 define void @void_func_v32i32(<32 x i32> %arg0) #0 {
|
|
|
214 store <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
215 ret void
|
|
|
216 }
|
|
|
217
|
|
|
218 ; 1 over register limit
|
|
|
219 ; GCN-LABEL: {{^}}void_func_v33i32:
|
|
|
220 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
221 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
222 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
223 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
224 ; GCN-DAG: buffer_load_dword [[STACKLOAD:v[0-9]+]], off, s[0:3], s5
|
|
|
225 ; GCN-DAG: buffer_store_dwordx4 v[16:19], off
|
|
|
226 ; GCN-DAG: buffer_store_dwordx4 v[20:23], off
|
|
|
227 ; GCN-DAG: buffer_store_dwordx4 v[24:27], off
|
|
|
228 ; GCN-DAG: buffer_store_dwordx4 v[28:31], off
|
|
|
229 ; GCN: buffer_store_dword [[STACKLOAD]], off
|
|
|
230 define void @void_func_v33i32(<33 x i32> %arg0) #0 {
|
|
|
231 store <33 x i32> %arg0, <33 x i32> addrspace(1)* undef
|
|
|
232 ret void
|
|
|
233 }
|
|
|
234
|
|
|
235 ; GCN-LABEL: {{^}}void_func_v2i64:
|
|
|
236 ; GCN: buffer_store_dwordx4 v[0:3], off
|
|
|
237 define void @void_func_v2i64(<2 x i64> %arg0) #0 {
|
|
|
238 store <2 x i64> %arg0, <2 x i64> addrspace(1)* undef
|
|
|
239 ret void
|
|
|
240 }
|
|
|
241
|
|
|
242 ; GCN-LABEL: {{^}}void_func_v3i64:
|
|
|
243 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
244 ; GCN-DAG: buffer_store_dwordx2 v[4:5], off
|
|
|
245 define void @void_func_v3i64(<3 x i64> %arg0) #0 {
|
|
|
246 store <3 x i64> %arg0, <3 x i64> addrspace(1)* undef
|
|
|
247 ret void
|
|
|
248 }
|
|
|
249
|
|
|
250 ; GCN-LABEL: {{^}}void_func_v4i64:
|
|
|
251 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
252 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
253 define void @void_func_v4i64(<4 x i64> %arg0) #0 {
|
|
|
254 store <4 x i64> %arg0, <4 x i64> addrspace(1)* undef
|
|
|
255 ret void
|
|
|
256 }
|
|
|
257
|
|
|
258 ; GCN-LABEL: {{^}}void_func_v5i64:
|
|
|
259 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
260 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
261 ; GCN-DAG: buffer_store_dwordx2 v[8:9], off
|
|
|
262 define void @void_func_v5i64(<5 x i64> %arg0) #0 {
|
|
|
263 store <5 x i64> %arg0, <5 x i64> addrspace(1)* undef
|
|
|
264 ret void
|
|
|
265 }
|
|
|
266
|
|
|
267 ; GCN-LABEL: {{^}}void_func_v8i64:
|
|
|
268 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
269 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
270 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
271 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
272 define void @void_func_v8i64(<8 x i64> %arg0) #0 {
|
|
|
273 store <8 x i64> %arg0, <8 x i64> addrspace(1)* undef
|
|
|
274 ret void
|
|
|
275 }
|
|
|
276
|
|
|
277 ; GCN-LABEL: {{^}}void_func_v16i64:
|
|
|
278 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
279 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
280 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
281 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
282 ; GCN-DAG: buffer_store_dwordx4 v[16:19], off
|
|
|
283 ; GCN-DAG: buffer_store_dwordx4 v[20:23], off
|
|
|
284 ; GCN-DAG: buffer_store_dwordx4 v[24:27], off
|
|
|
285 ; GCN-DAG: buffer_store_dwordx4 v[28:31], off
|
|
|
286 define void @void_func_v16i64(<16 x i64> %arg0) #0 {
|
|
|
287 store <16 x i64> %arg0, <16 x i64> addrspace(1)* undef
|
|
|
288 ret void
|
|
|
289 }
|
|
|
290
|
|
|
291 ; GCN-LABEL: {{^}}void_func_v2i16:
|
|
|
292 ; GFX9-NOT: v0
|
|
|
293 ; GFX9: buffer_store_dword v0, off
|
|
|
294 define void @void_func_v2i16(<2 x i16> %arg0) #0 {
|
|
|
295 store <2 x i16> %arg0, <2 x i16> addrspace(1)* undef
|
|
|
296 ret void
|
|
|
297 }
|
|
|
298
|
|
|
299 ; GCN-LABEL: {{^}}void_func_v3i16:
|
|
|
300 ; GCN-DAG: buffer_store_dword v0, off
|
|
|
301 ; GCN-DAG: buffer_store_short v2, off
|
|
|
302 define void @void_func_v3i16(<3 x i16> %arg0) #0 {
|
|
|
303 store <3 x i16> %arg0, <3 x i16> addrspace(1)* undef
|
|
|
304 ret void
|
|
|
305 }
|
|
|
306
|
|
|
307 ; GCN-LABEL: {{^}}void_func_v4i16:
|
|
|
308 ; GFX9-NOT: v0
|
|
|
309 ; GFX9-NOT: v1
|
|
|
310 ; GFX9: buffer_store_dwordx2 v[0:1], off
|
|
|
311 define void @void_func_v4i16(<4 x i16> %arg0) #0 {
|
|
|
312 store <4 x i16> %arg0, <4 x i16> addrspace(1)* undef
|
|
|
313 ret void
|
|
|
314 }
|
|
|
315
|
|
|
316 ; GCN-LABEL: {{^}}void_func_v5i16:
|
|
|
317 ; GCN-DAG: buffer_store_short v4, off,
|
|
|
318 ; GCN-DAG: buffer_store_dwordx2 v[1:2], off
|
|
|
319 define void @void_func_v5i16(<5 x i16> %arg0) #0 {
|
|
|
320 store <5 x i16> %arg0, <5 x i16> addrspace(1)* undef
|
|
|
321 ret void
|
|
|
322 }
|
|
|
323
|
|
|
324 ; GCN-LABEL: {{^}}void_func_v8i16:
|
|
|
325 ; GFX9-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
326 define void @void_func_v8i16(<8 x i16> %arg0) #0 {
|
|
|
327 store <8 x i16> %arg0, <8 x i16> addrspace(1)* undef
|
|
|
328 ret void
|
|
|
329 }
|
|
|
330
|
|
|
331 ; GCN-LABEL: {{^}}void_func_v16i16:
|
|
|
332 ; GFX9-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
333 ; GFX9-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
334 define void @void_func_v16i16(<16 x i16> %arg0) #0 {
|
|
|
335 store <16 x i16> %arg0, <16 x i16> addrspace(1)* undef
|
|
|
336 ret void
|
|
|
337 }
|
|
|
338
|
|
|
339 ; GCN-LABEL: {{^}}void_func_v2f32:
|
|
|
340 ; GCN-NOT: v[0:1]
|
|
|
341 ; GCN-NOT: v0
|
|
|
342 ; GCN-NOT: v1
|
|
|
343 ; GCN: buffer_store_dwordx2 v[0:1], off
|
|
|
344 define void @void_func_v2f32(<2 x float> %arg0) #0 {
|
|
|
345 store <2 x float> %arg0, <2 x float> addrspace(1)* undef
|
|
|
346 ret void
|
|
|
347 }
|
|
|
348
|
|
|
349 ; GCN-LABEL: {{^}}void_func_v3f32:
|
|
|
350 ; GCN-DAG: buffer_store_dword v2, off
|
|
|
351 ; GCN-DAG: buffer_store_dwordx2 v[0:1], off
|
|
|
352 define void @void_func_v3f32(<3 x float> %arg0) #0 {
|
|
|
353 store <3 x float> %arg0, <3 x float> addrspace(1)* undef
|
|
|
354 ret void
|
|
|
355 }
|
|
|
356
|
|
|
357 ; GCN-LABEL: {{^}}void_func_v4f32:
|
|
|
358 ; GCN: buffer_store_dwordx4 v[0:3], off
|
|
|
359 define void @void_func_v4f32(<4 x float> %arg0) #0 {
|
|
|
360 store <4 x float> %arg0, <4 x float> addrspace(1)* undef
|
|
|
361 ret void
|
|
|
362 }
|
|
|
363
|
|
|
364 ; GCN-LABEL: {{^}}void_func_v8f32:
|
|
|
365 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
366 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
367 define void @void_func_v8f32(<8 x float> %arg0) #0 {
|
|
|
368 store <8 x float> %arg0, <8 x float> addrspace(1)* undef
|
|
|
369 ret void
|
|
|
370 }
|
|
|
371
|
|
|
372 ; GCN-LABEL: {{^}}void_func_v16f32:
|
|
|
373 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
374 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
375 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
376 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
377 define void @void_func_v16f32(<16 x float> %arg0) #0 {
|
|
|
378 store <16 x float> %arg0, <16 x float> addrspace(1)* undef
|
|
|
379 ret void
|
|
|
380 }
|
|
|
381
|
|
|
382 ; GCN-LABEL: {{^}}void_func_v2f64:
|
|
|
383 ; GCN: buffer_store_dwordx4 v[0:3], off
|
|
|
384 define void @void_func_v2f64(<2 x double> %arg0) #0 {
|
|
|
385 store <2 x double> %arg0, <2 x double> addrspace(1)* undef
|
|
|
386 ret void
|
|
|
387 }
|
|
|
388
|
|
|
389 ; GCN-LABEL: {{^}}void_func_v3f64:
|
|
|
390 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
391 ; GCN-DAG: buffer_store_dwordx2 v[4:5], off
|
|
|
392 define void @void_func_v3f64(<3 x double> %arg0) #0 {
|
|
|
393 store <3 x double> %arg0, <3 x double> addrspace(1)* undef
|
|
|
394 ret void
|
|
|
395 }
|
|
|
396
|
|
|
397 ; GCN-LABEL: {{^}}void_func_v4f64:
|
|
|
398 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
399 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
400 define void @void_func_v4f64(<4 x double> %arg0) #0 {
|
|
|
401 store <4 x double> %arg0, <4 x double> addrspace(1)* undef
|
|
|
402 ret void
|
|
|
403 }
|
|
|
404
|
|
|
405 ; GCN-LABEL: {{^}}void_func_v8f64:
|
|
|
406 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
407 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
408 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
409 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
410 define void @void_func_v8f64(<8 x double> %arg0) #0 {
|
|
|
411 store <8 x double> %arg0, <8 x double> addrspace(1)* undef
|
|
|
412 ret void
|
|
|
413 }
|
|
|
414
|
|
|
415 ; GCN-LABEL: {{^}}void_func_v16f64:
|
|
|
416 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
417 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
418 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
419 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
420 ; GCN-DAG: buffer_store_dwordx4 v[16:19], off
|
|
|
421 ; GCN-DAG: buffer_store_dwordx4 v[20:23], off
|
|
|
422 ; GCN-DAG: buffer_store_dwordx4 v[24:27], off
|
|
|
423 ; GCN-DAG: buffer_store_dwordx4 v[28:31], off
|
|
|
424 define void @void_func_v16f64(<16 x double> %arg0) #0 {
|
|
|
425 store <16 x double> %arg0, <16 x double> addrspace(1)* undef
|
|
|
426 ret void
|
|
|
427 }
|
|
|
428
|
|
|
429 ; GCN-LABEL: {{^}}void_func_v2f16:
|
|
|
430 ; GFX9-NOT: v0
|
|
|
431 ; GFX9: buffer_store_dword v0, off
|
|
|
432 define void @void_func_v2f16(<2 x half> %arg0) #0 {
|
|
|
433 store <2 x half> %arg0, <2 x half> addrspace(1)* undef
|
|
|
434 ret void
|
|
|
435 }
|
|
|
436
|
|
|
437 ; GCN-LABEL: {{^}}void_func_v3f16:
|
|
|
438 ; GFX9-NOT: v0
|
|
|
439 ; GCN-DAG: buffer_store_dword v0, off
|
|
|
440 ; GCN-DAG: buffer_store_short v2, off
|
|
|
441 define void @void_func_v3f16(<3 x half> %arg0) #0 {
|
|
|
442 store <3 x half> %arg0, <3 x half> addrspace(1)* undef
|
|
|
443 ret void
|
|
|
444 }
|
|
|
445
|
|
|
446 ; GCN-LABEL: {{^}}void_func_v4f16:
|
|
|
447 ; GFX9-NOT: v0
|
|
|
448 ; GFX9-NOT: v1
|
|
|
449 ; GFX9-NOT: v[0:1]
|
|
|
450 ; GFX9: buffer_store_dwordx2 v[0:1], off
|
|
|
451 define void @void_func_v4f16(<4 x half> %arg0) #0 {
|
|
|
452 store <4 x half> %arg0, <4 x half> addrspace(1)* undef
|
|
|
453 ret void
|
|
|
454 }
|
|
|
455
|
|
|
456 ; GCN-LABEL: {{^}}void_func_v8f16:
|
|
|
457 ; GFX9-NOT: v0
|
|
|
458 ; GFX9-NOT: v1
|
|
|
459 ; GFX9: buffer_store_dwordx4 v[0:3], off
|
|
|
460 define void @void_func_v8f16(<8 x half> %arg0) #0 {
|
|
|
461 store <8 x half> %arg0, <8 x half> addrspace(1)* undef
|
|
|
462 ret void
|
|
|
463 }
|
|
|
464
|
|
|
465 ; GCN-LABEL: {{^}}void_func_v16f16:
|
|
|
466 ; GFX9-NOT: v0
|
|
|
467 ; GFX9-NOT: v1
|
|
|
468 ; GFX9-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
469 ; GFX9-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
470 define void @void_func_v16f16(<16 x half> %arg0) #0 {
|
|
|
471 store <16 x half> %arg0, <16 x half> addrspace(1)* undef
|
|
|
472 ret void
|
|
|
473 }
|
|
|
474
|
|
|
475 ; Make sure there is no alignment requirement for passed vgprs.
|
|
|
476 ; GCN-LABEL: {{^}}void_func_i32_i64_i32:
|
|
|
477 ; GCN-NOT: v0
|
|
|
478 ; GCN: buffer_store_dword v0, off
|
|
|
479 ; GCN: buffer_store_dwordx2 v[1:2]
|
|
|
480 ; GCN: buffer_store_dword v3
|
|
|
481 define void @void_func_i32_i64_i32(i32 %arg0, i64 %arg1, i32 %arg2) #0 {
|
|
|
482 store volatile i32 %arg0, i32 addrspace(1)* undef
|
|
|
483 store volatile i64 %arg1, i64 addrspace(1)* undef
|
|
|
484 store volatile i32 %arg2, i32 addrspace(1)* undef
|
|
|
485 ret void
|
|
|
486 }
|
|
|
487
|
|
|
488 ; GCN-LABEL: {{^}}void_func_struct_i32:
|
|
|
489 ; GCN-NOT: v0
|
|
|
490 ; GCN: buffer_store_dword v0, off
|
|
|
491 define void @void_func_struct_i32({ i32 } %arg0) #0 {
|
|
|
492 store { i32 } %arg0, { i32 } addrspace(1)* undef
|
|
|
493 ret void
|
|
|
494 }
|
|
|
495
|
|
|
496 ; GCN-LABEL: {{^}}void_func_struct_i8_i32:
|
|
|
497 ; GCN-DAG: buffer_store_byte v0, off
|
|
|
498 ; GCN-DAG: buffer_store_dword v1, off
|
|
|
499 define void @void_func_struct_i8_i32({ i8, i32 } %arg0) #0 {
|
|
|
500 store { i8, i32 } %arg0, { i8, i32 } addrspace(1)* undef
|
|
|
501 ret void
|
|
|
502 }
|
|
|
503
|
|
|
504 ; GCN-LABEL: {{^}}void_func_byval_struct_i8_i32:
|
|
|
505 ; GCN-DAG: buffer_load_ubyte v[[ELT0:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
506 ; GCN-DAG: buffer_load_dword v[[ELT1:[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
507 ; GCN-DAG: buffer_store_dword v[[ELT1]]
|
|
|
508 ; GCN-DAG: buffer_store_byte v[[ELT0]]
|
|
134
|
509 define void @void_func_byval_struct_i8_i32({ i8, i32 } addrspace(5)* byval %arg0) #0 {
|
|
|
510 %arg0.load = load { i8, i32 }, { i8, i32 } addrspace(5)* %arg0
|
|
121
|
511 store { i8, i32 } %arg0.load, { i8, i32 } addrspace(1)* undef
|
|
|
512 ret void
|
|
|
513 }
|
|
|
514
|
|
|
515 ; GCN-LABEL: {{^}}void_func_byval_struct_i8_i32_x2:
|
|
|
516 ; GCN: buffer_load_ubyte v[[ELT0_0:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
517 ; GCN: buffer_load_dword v[[ELT1_0:[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
518 ; GCN: buffer_load_ubyte v[[ELT0_1:[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
519 ; GCN: buffer_load_dword v[[ELT1_1:[0-9]+]], off, s[0:3], s5 offset:16{{$}}
|
|
|
520
|
|
|
521 ; GCN: ds_write_b32 v0, v0
|
|
|
522 ; GCN: s_setpc_b64
|
|
134
|
523 define void @void_func_byval_struct_i8_i32_x2({ i8, i32 } addrspace(5)* byval %arg0, { i8, i32 } addrspace(5)* byval %arg1, i32 %arg2) #0 {
|
|
|
524 %arg0.load = load volatile { i8, i32 }, { i8, i32 } addrspace(5)* %arg0
|
|
|
525 %arg1.load = load volatile { i8, i32 }, { i8, i32 } addrspace(5)* %arg1
|
|
121
|
526 store volatile { i8, i32 } %arg0.load, { i8, i32 } addrspace(1)* undef
|
|
|
527 store volatile { i8, i32 } %arg1.load, { i8, i32 } addrspace(1)* undef
|
|
|
528 store volatile i32 %arg2, i32 addrspace(3)* undef
|
|
|
529 ret void
|
|
|
530 }
|
|
|
531
|
|
|
532 ; GCN-LABEL: {{^}}void_func_byval_i32_byval_i64:
|
|
|
533 ; GCN-DAG: buffer_load_dword v[[ARG0_LOAD:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
534 ; GCN-DAG: buffer_load_dword v[[ARG1_LOAD0:[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
535 ; GCN-DAG: buffer_load_dword v[[ARG1_LOAD1:[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
536 ; GCN-DAG: buffer_store_dword v[[ARG0_LOAD]], off
|
|
|
537 ; GCN-DAG: buffer_store_dwordx2 v{{\[}}[[ARG1_LOAD0]]:[[ARG1_LOAD1]]{{\]}}, off
|
|
134
|
538 define void @void_func_byval_i32_byval_i64(i32 addrspace(5)* byval %arg0, i64 addrspace(5)* byval %arg1) #0 {
|
|
|
539 %arg0.load = load i32, i32 addrspace(5)* %arg0
|
|
|
540 %arg1.load = load i64, i64 addrspace(5)* %arg1
|
|
121
|
541 store i32 %arg0.load, i32 addrspace(1)* undef
|
|
|
542 store i64 %arg1.load, i64 addrspace(1)* undef
|
|
|
543 ret void
|
|
|
544 }
|
|
|
545
|
|
|
546 ; GCN-LABEL: {{^}}void_func_v32i32_i32_i64:
|
|
|
547 ; GCN-DAG: buffer_store_dwordx4 v[0:3], off
|
|
|
548 ; GCN-DAG: buffer_store_dwordx4 v[4:7], off
|
|
|
549 ; GCN-DAG: buffer_store_dwordx4 v[8:11], off
|
|
|
550 ; GCN-DAG: buffer_store_dwordx4 v[12:15], off
|
|
|
551 ; GCN-DAG: buffer_store_dwordx4 v[16:19], off
|
|
|
552 ; GCN-DAG: buffer_store_dwordx4 v[20:23], off
|
|
|
553 ; GCN-DAG: buffer_store_dwordx4 v[24:27], off
|
|
|
554 ; GCN-DAG: buffer_store_dwordx4 v[28:31], off
|
|
|
555 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
556 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_0:[0-9]+]], off, s[0:3], s5 offset:8
|
|
|
557 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_1:[0-9]+]], off, s[0:3], s5 offset:12
|
|
|
558
|
|
|
559 ; GCN: buffer_store_dword v[[LOAD_ARG1]]
|
|
|
560 ; GCN: buffer_store_dwordx2 v{{\[}}[[LOAD_ARG2_0]]:[[LOAD_ARG2_1]]{{\]}}, off
|
|
|
561 define void @void_func_v32i32_i32_i64(<32 x i32> %arg0, i32 %arg1, i64 %arg2) #0 {
|
|
|
562 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
563 store volatile i32 %arg1, i32 addrspace(1)* undef
|
|
|
564 store volatile i64 %arg2, i64 addrspace(1)* undef
|
|
|
565 ret void
|
|
|
566 }
|
|
|
567
|
|
|
568 ; FIXME: Different ext load types on CI vs. VI
|
|
|
569 ; GCN-LABEL: {{^}}void_func_v32i32_i1_i8_i16:
|
|
|
570 ; GCN-DAG: buffer_load_ubyte [[LOAD_ARG1:v[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
571 ; VI-DAG: buffer_load_ushort [[LOAD_ARG2:v[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
572 ; VI-DAG: buffer_load_ushort [[LOAD_ARG3:v[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
573 ; VI-DAG: buffer_load_ushort [[LOAD_ARG4:v[0-9]+]], off, s[0:3], s5 offset:16{{$}}
|
|
|
574
|
|
|
575 ; CI-DAG: buffer_load_dword [[LOAD_ARG2:v[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
576 ; CI-DAG: buffer_load_dword [[LOAD_ARG3:v[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
577 ; CI-DAG: buffer_load_dword [[LOAD_ARG4:v[0-9]+]], off, s[0:3], s5 offset:16{{$}}
|
|
|
578
|
|
|
579 ; GCN-DAG: v_and_b32_e32 [[TRUNC_ARG1_I1:v[0-9]+]], 1, [[LOAD_ARG1]]
|
|
|
580 ; CI-DAG: v_cvt_f16_f32_e32 [[CVT_ARG4:v[0-9]+]], [[LOAD_ARG4]]
|
|
|
581
|
|
|
582 ; GCN: buffer_store_byte [[TRUNC_ARG1_I1]], off
|
|
|
583 ; GCN: buffer_store_byte [[LOAD_ARG2]], off
|
|
|
584 ; GCN: buffer_store_short [[LOAD_ARG3]], off
|
|
134
|
585 ; GFX89 buffer_store_short [[LOAD_ARG4]], off
|
|
121
|
586
|
|
|
587 ; CI: buffer_store_short [[CVT_ARG4]], off
|
|
|
588 define void @void_func_v32i32_i1_i8_i16(<32 x i32> %arg0, i1 %arg1, i8 %arg2, i16 %arg3, half %arg4) #0 {
|
|
|
589 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
590 store volatile i1 %arg1, i1 addrspace(1)* undef
|
|
|
591 store volatile i8 %arg2, i8 addrspace(1)* undef
|
|
|
592 store volatile i16 %arg3, i16 addrspace(1)* undef
|
|
|
593 store volatile half %arg4, half addrspace(1)* undef
|
|
|
594 ret void
|
|
|
595 }
|
|
|
596
|
|
|
597 ; GCN-LABEL: {{^}}void_func_v32i32_v2i32_v2f32:
|
|
|
598 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_0:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
599 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_1:[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
600 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_0:[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
601 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_1:[0-9]+]], off, s[0:3], s5 offset:16{{$}}
|
|
|
602
|
|
|
603 ; GCN: buffer_store_dwordx2 v{{\[}}[[LOAD_ARG1_0]]:[[LOAD_ARG1_1]]{{\]}}, off
|
|
|
604 ; GCN: buffer_store_dwordx2 v{{\[}}[[LOAD_ARG2_0]]:[[LOAD_ARG2_1]]{{\]}}, off
|
|
|
605 define void @void_func_v32i32_v2i32_v2f32(<32 x i32> %arg0, <2 x i32> %arg1, <2 x float> %arg2) #0 {
|
|
|
606 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
607 store volatile <2 x i32> %arg1, <2 x i32> addrspace(1)* undef
|
|
|
608 store volatile <2 x float> %arg2, <2 x float> addrspace(1)* undef
|
|
|
609 ret void
|
|
|
610 }
|
|
|
611
|
|
|
612 ; GCN-LABEL: {{^}}void_func_v32i32_v2i16_v2f16:
|
|
|
613 ; GFX9-DAG: buffer_load_dword [[LOAD_ARG1:v[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
614 ; GFX9-DAG: buffer_load_dword [[LOAD_ARG2:v[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
615 ; GFX9: buffer_store_dword [[LOAD_ARG1]], off
|
|
|
616 ; GFX9: buffer_store_short [[LOAD_ARG2]], off
|
|
|
617 define void @void_func_v32i32_v2i16_v2f16(<32 x i32> %arg0, <2 x i16> %arg1, <2 x half> %arg2) #0 {
|
|
|
618 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
619 store volatile <2 x i16> %arg1, <2 x i16> addrspace(1)* undef
|
|
|
620 store volatile <2 x half> %arg2, <2 x half> addrspace(1)* undef
|
|
|
621 ret void
|
|
|
622 }
|
|
|
623
|
|
|
624 ; GCN-LABEL: {{^}}void_func_v32i32_v2i64_v2f64:
|
|
|
625 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_0:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
626 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_1:[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
627 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_2:[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
628 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_3:[0-9]+]], off, s[0:3], s5 offset:16{{$}}
|
|
|
629
|
|
|
630 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_0:[0-9]+]], off, s[0:3], s5 offset:20{{$}}
|
|
|
631 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_1:[0-9]+]], off, s[0:3], s5 offset:24{{$}}
|
|
|
632 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_2:[0-9]+]], off, s[0:3], s5 offset:28{{$}}
|
|
|
633 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_3:[0-9]+]], off, s[0:3], s5 offset:32{{$}}
|
|
|
634
|
|
|
635 ; GCN: buffer_store_dwordx4 v{{\[}}[[LOAD_ARG1_0]]:[[LOAD_ARG1_3]]{{\]}}, off
|
|
|
636 ; GCN: buffer_store_dwordx4 v{{\[}}[[LOAD_ARG2_0]]:[[LOAD_ARG2_3]]{{\]}}, off
|
|
|
637 define void @void_func_v32i32_v2i64_v2f64(<32 x i32> %arg0, <2 x i64> %arg1, <2 x double> %arg2) #0 {
|
|
|
638 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
639 store volatile <2 x i64> %arg1, <2 x i64> addrspace(1)* undef
|
|
|
640 store volatile <2 x double> %arg2, <2 x double> addrspace(1)* undef
|
|
|
641 ret void
|
|
|
642 }
|
|
|
643
|
|
|
644 ; GCN-LABEL: {{^}}void_func_v32i32_v4i32_v4f32:
|
|
|
645 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_0:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
646 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_1:[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
647 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_2:[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
648 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_3:[0-9]+]], off, s[0:3], s5 offset:16{{$}}
|
|
|
649
|
|
|
650 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_0:[0-9]+]], off, s[0:3], s5 offset:20{{$}}
|
|
|
651 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_1:[0-9]+]], off, s[0:3], s5 offset:24{{$}}
|
|
|
652 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_2:[0-9]+]], off, s[0:3], s5 offset:28{{$}}
|
|
|
653 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_3:[0-9]+]], off, s[0:3], s5 offset:32{{$}}
|
|
|
654
|
|
|
655 ; GCN: buffer_store_dwordx4 v{{\[}}[[LOAD_ARG1_0]]:[[LOAD_ARG1_3]]{{\]}}, off
|
|
|
656 ; GCN: buffer_store_dwordx4 v{{\[}}[[LOAD_ARG2_0]]:[[LOAD_ARG2_3]]{{\]}}, off
|
|
|
657 define void @void_func_v32i32_v4i32_v4f32(<32 x i32> %arg0, <4 x i32> %arg1, <4 x float> %arg2) #0 {
|
|
|
658 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
659 store volatile <4 x i32> %arg1, <4 x i32> addrspace(1)* undef
|
|
|
660 store volatile <4 x float> %arg2, <4 x float> addrspace(1)* undef
|
|
|
661 ret void
|
|
|
662 }
|
|
|
663
|
|
|
664 ; GCN-LABEL: {{^}}void_func_v32i32_v8i32_v8f32:
|
|
|
665 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_0:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
666 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_1:[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
667 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_2:[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
668 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_3:[0-9]+]], off, s[0:3], s5 offset:16{{$}}
|
|
|
669 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_4:[0-9]+]], off, s[0:3], s5 offset:20{{$}}
|
|
|
670 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_5:[0-9]+]], off, s[0:3], s5 offset:24{{$}}
|
|
|
671 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_6:[0-9]+]], off, s[0:3], s5 offset:28{{$}}
|
|
|
672 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_7:[0-9]+]], off, s[0:3], s5 offset:32{{$}}
|
|
|
673
|
|
|
674 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_0:[0-9]+]], off, s[0:3], s5 offset:36{{$}}
|
|
|
675 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_1:[0-9]+]], off, s[0:3], s5 offset:40{{$}}
|
|
|
676 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_2:[0-9]+]], off, s[0:3], s5 offset:44{{$}}
|
|
|
677 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_3:[0-9]+]], off, s[0:3], s5 offset:48{{$}}
|
|
|
678 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_4:[0-9]+]], off, s[0:3], s5 offset:52{{$}}
|
|
|
679 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_5:[0-9]+]], off, s[0:3], s5 offset:56{{$}}
|
|
|
680 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_6:[0-9]+]], off, s[0:3], s5 offset:60{{$}}
|
|
|
681 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_7:[0-9]+]], off, s[0:3], s5 offset:64{{$}}
|
|
|
682
|
|
|
683 ; GCN: buffer_store_dwordx4 v{{\[}}[[LOAD_ARG1_4]]:[[LOAD_ARG1_7]]{{\]}}, off
|
|
|
684 ; GCN: buffer_store_dwordx4 v{{\[}}[[LOAD_ARG1_0]]:[[LOAD_ARG1_3]]{{\]}}, off
|
|
|
685 ; GCN: buffer_store_dwordx4 v{{\[}}[[LOAD_ARG2_4]]:[[LOAD_ARG2_7]]{{\]}}, off
|
|
|
686 ; GCN: buffer_store_dwordx4 v{{\[}}[[LOAD_ARG2_0]]:[[LOAD_ARG2_3]]{{\]}}, off
|
|
|
687 define void @void_func_v32i32_v8i32_v8f32(<32 x i32> %arg0, <8 x i32> %arg1, <8 x float> %arg2) #0 {
|
|
|
688 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
689 store volatile <8 x i32> %arg1, <8 x i32> addrspace(1)* undef
|
|
|
690 store volatile <8 x float> %arg2, <8 x float> addrspace(1)* undef
|
|
|
691 ret void
|
|
|
692 }
|
|
|
693
|
|
|
694 ; GCN-LABEL: {{^}}void_func_v32i32_v16i32_v16f32:
|
|
|
695 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_0:[0-9]+]], off, s[0:3], s5 offset:4{{$}}
|
|
|
696 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_1:[0-9]+]], off, s[0:3], s5 offset:8{{$}}
|
|
|
697 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_2:[0-9]+]], off, s[0:3], s5 offset:12{{$}}
|
|
|
698 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_:[0-9]+]], off, s[0:3], s5 offset:16{{$}}
|
|
|
699 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_4:[0-9]+]], off, s[0:3], s5 offset:20{{$}}
|
|
|
700 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_5:[0-9]+]], off, s[0:3], s5 offset:24{{$}}
|
|
|
701 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_6:[0-9]+]], off, s[0:3], s5 offset:28{{$}}
|
|
|
702 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_7:[0-9]+]], off, s[0:3], s5 offset:32{{$}}
|
|
|
703 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_8:[0-9]+]], off, s[0:3], s5 offset:36{{$}}
|
|
|
704 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_9:[0-9]+]], off, s[0:3], s5 offset:40{{$}}
|
|
|
705 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_10:[0-9]+]], off, s[0:3], s5 offset:44{{$}}
|
|
|
706 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_11:[0-9]+]], off, s[0:3], s5 offset:48{{$}}
|
|
|
707 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_12:[0-9]+]], off, s[0:3], s5 offset:52{{$}}
|
|
|
708 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_13:[0-9]+]], off, s[0:3], s5 offset:56{{$}}
|
|
|
709 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG1_14:[0-9]+]], off, s[0:3], s5 offset:60{{$}}
|
|
|
710 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_15:[0-9]+]], off, s[0:3], s5 offset:64{{$}}
|
|
|
711
|
|
|
712 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_0:[0-9]+]], off, s[0:3], s5 offset:68{{$}}
|
|
|
713 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_1:[0-9]+]], off, s[0:3], s5 offset:72{{$}}
|
|
|
714 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_2:[0-9]+]], off, s[0:3], s5 offset:76{{$}}
|
|
|
715 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_3:[0-9]+]], off, s[0:3], s5 offset:80{{$}}
|
|
|
716 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_4:[0-9]+]], off, s[0:3], s5 offset:84{{$}}
|
|
|
717 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_5:[0-9]+]], off, s[0:3], s5 offset:88{{$}}
|
|
|
718 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_6:[0-9]+]], off, s[0:3], s5 offset:92{{$}}
|
|
|
719 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_7:[0-9]+]], off, s[0:3], s5 offset:96{{$}}
|
|
|
720 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_8:[0-9]+]], off, s[0:3], s5 offset:100{{$}}
|
|
|
721 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_9:[0-9]+]], off, s[0:3], s5 offset:104{{$}}
|
|
|
722 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_10:[0-9]+]], off, s[0:3], s5 offset:108{{$}}
|
|
|
723 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_11:[0-9]+]], off, s[0:3], s5 offset:112{{$}}
|
|
|
724 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_12:[0-9]+]], off, s[0:3], s5 offset:116{{$}}
|
|
|
725 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_13:[0-9]+]], off, s[0:3], s5 offset:120{{$}}
|
|
|
726 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_14:[0-9]+]], off, s[0:3], s5 offset:124{{$}}
|
|
|
727 ; GCN-DAG: buffer_load_dword v[[LOAD_ARG2_15:[0-9]+]], off, s[0:3], s5 offset:128{{$}}
|
|
|
728 define void @void_func_v32i32_v16i32_v16f32(<32 x i32> %arg0, <16 x i32> %arg1, <16 x float> %arg2) #0 {
|
|
|
729 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
730 store volatile <16 x i32> %arg1, <16 x i32> addrspace(1)* undef
|
|
|
731 store volatile <16 x float> %arg2, <16 x float> addrspace(1)* undef
|
|
|
732 ret void
|
|
|
733 }
|
|
|
734
|
|
|
735 ; Check there is no crash.
|
|
|
736 ; GCN-LABEL: {{^}}void_func_v16i8:
|
|
|
737 define void @void_func_v16i8(<16 x i8> %arg0) #0 {
|
|
|
738 store volatile <16 x i8> %arg0, <16 x i8> addrspace(1)* undef
|
|
|
739 ret void
|
|
|
740 }
|
|
|
741
|
|
|
742 ; Check there is no crash.
|
|
|
743 ; GCN-LABEL: {{^}}void_func_v32i32_v16i8:
|
|
|
744 define void @void_func_v32i32_v16i8(<32 x i32> %arg0, <16 x i8> %arg1) #0 {
|
|
|
745 store volatile <32 x i32> %arg0, <32 x i32> addrspace(1)* undef
|
|
|
746 store volatile <16 x i8> %arg1, <16 x i8> addrspace(1)* undef
|
|
|
747 ret void
|
|
|
748 }
|
|
|
749
|
|
|
750 attributes #0 = { nounwind }
|
