| blob | 099a26afb940b2560eda693ccfd889ee03d4bd92 |
1 ; Verifies correctness of load/store of parameters and return values.\r
2 ; RUN: llc < %s -march=nvptx64 -mcpu=sm_35 -O0 -verify-machineinstrs | FileCheck -allow-deprecated-dag-overlap %s\r
3 \r
4 %s_i1 = type { i1 }\r
5 %s_i8 = type { i8 }\r
6 %s_i16 = type { i16 }\r
7 %s_f16 = type { half }\r
8 %s_i32 = type { i32 }\r
9 %s_f32 = type { float }\r
10 %s_i64 = type { i64 }\r
11 %s_f64 = type { double }\r
12 \r
13 ; More complicated types. i64 is used to increase natural alignment\r
14 ; requirement for the type.\r
15 %s_i32x4 = type { i32, i32, i32, i32, i64}\r
16 %s_i32f32 = type { i32, float, i32, float, i64}\r
17 %s_i8i32x4 = type { i32, i32, i8, i32, i32, i64}\r
18 %s_i8i32x4p = type <{ i32, i32, i8, i32, i32, i64}>\r
19 %s_crossfield = type { i32, [2 x i32], <4 x i32>, [3 x {i32, i32, i32}]}\r
20 ; All scalar parameters must be at least 32 bits in size.\r
21 ; i1 is loaded/stored as i8.\r
22 \r
23 ; CHECK: .func (.param .b32 func_retval0)\r
24 ; CHECK-LABEL: test_i1(\r
25 ; CHECK-NEXT: .param .b32 test_i1_param_0\r
26 ; CHECK: ld.param.u8 [[A8:%rs[0-9]+]], [test_i1_param_0];\r
27 ; CHECK: and.b16 [[A:%rs[0-9]+]], [[A8]], 1;\r
28 ; CHECK: setp.eq.b16 %p1, [[A]], 1\r
29 ; CHECK: cvt.u32.u16 [[B:%r[0-9]+]], [[A8]]\r
30 ; CHECK: and.b32 [[C:%r[0-9]+]], [[B]], 1;\r
31 ; CHECK: .param .b32 param0;\r
32 ; CHECK: st.param.b32 [param0+0], [[C]]\r
33 ; CHECK: .param .b32 retval0;\r
34 ; CHECK: call.uni\r
35 ; CHECK-NEXT: test_i1,\r
36 ; CHECK: ld.param.b32 [[R8:%r[0-9]+]], [retval0+0];\r
37 ; CHECK: and.b32 [[R:%r[0-9]+]], [[R8]], 1;\r
38 ; CHECK: st.param.b32 [func_retval0+0], [[R]];\r
39 ; CHECK: ret;\r
40 define i1 @test_i1(i1 %a) {\r
41 %r = tail call i1 @test_i1(i1 %a);\r
42 ret i1 %r;\r
43 }\r
44 \r
45 ; Signed i1 is a somewhat special case. We only care about one bit and\r
46 ; then us neg.s32 to convert it to 32-bit -1 if it's set.\r
47 ; CHECK: .func (.param .b32 func_retval0)\r
48 ; CHECK-LABEL: test_i1s(\r
49 ; CHECK-NEXT: .param .b32 test_i1s_param_0\r
50 ; CHECK: ld.param.u8 [[A8:%rs[0-9]+]], [test_i1s_param_0];\r
51 ; CHECK: cvt.u32.u16 [[A32:%r[0-9]+]], [[A8]];\r
52 ; CHECK: and.b32 [[A1:%r[0-9]+]], [[A32]], 1;\r
53 ; CHECK: neg.s32 [[A:%r[0-9]+]], [[A1]];\r
54 ; CHECK: .param .b32 param0;\r
55 ; CHECK: st.param.b32 [param0+0], [[A]];\r
56 ; CHECK: .param .b32 retval0;\r
57 ; CHECK: call.uni\r
58 ; CHECK: ld.param.b32 [[R8:%r[0-9]+]], [retval0+0];\r
59 ; CHECK: and.b32 [[R1:%r[0-9]+]], [[R8]], 1;\r
60 ; CHECK: neg.s32 [[R:%r[0-9]+]], [[R1]];\r
61 ; CHECK: st.param.b32 [func_retval0+0], [[R]];\r
62 ; CHECK-NEXT: ret;\r
63 define signext i1 @test_i1s(i1 signext %a) {\r
64 %r = tail call signext i1 @test_i1s(i1 signext %a);\r
65 ret i1 %r;\r
66 }\r
67 \r
68 ; Make sure that i1 loads are vectorized as i8 loads, respecting each element alignment.\r
69 ; CHECK: .func (.param .align 1 .b8 func_retval0[1])\r
70 ; CHECK-LABEL: test_v3i1(\r
71 ; CHECK-NEXT: .param .align 1 .b8 test_v3i1_param_0[1]\r
72 ; CHECK-DAG: ld.param.u8 [[E2:%rs[0-9]+]], [test_v3i1_param_0+2];\r
73 ; CHECK-DAG: ld.param.u8 [[E0:%rs[0-9]+]], [test_v3i1_param_0]\r
74 ; CHECK: .param .align 1 .b8 param0[1];\r
75 ; CHECK-DAG: st.param.b8 [param0+0], [[E0]];\r
76 ; CHECK-DAG: st.param.b8 [param0+2], [[E2]];\r
77 ; CHECK: .param .align 1 .b8 retval0[1];\r
78 ; CHECK: call.uni (retval0),\r
79 ; CHECK-NEXT: test_v3i1,\r
80 ; CHECK-DAG: ld.param.b8 [[RE0:%rs[0-9]+]], [retval0+0];\r
81 ; CHECK-DAG: ld.param.b8 [[RE2:%rs[0-9]+]], [retval0+2];\r
82 ; CHECK-DAG: st.param.b8 [func_retval0+0], [[RE0]]\r
83 ; CHECK-DAG: st.param.b8 [func_retval0+2], [[RE2]];\r
84 ; CHECK-NEXT: ret;\r
85 define <3 x i1> @test_v3i1(<3 x i1> %a) {\r
86 %r = tail call <3 x i1> @test_v3i1(<3 x i1> %a);\r
87 ret <3 x i1> %r;\r
88 }\r
89 \r
90 ; CHECK: .func (.param .align 1 .b8 func_retval0[1])\r
91 ; CHECK-LABEL: test_v4i1(\r
92 ; CHECK-NEXT: .param .align 1 .b8 test_v4i1_param_0[1]\r
93 ; CHECK: ld.param.u8 [[E0:%rs[0-9]+]], [test_v4i1_param_0]\r
94 ; CHECK: .param .align 1 .b8 param0[1];\r
95 ; CHECK: st.param.b8 [param0+0], [[E0]];\r
96 ; CHECK: .param .align 1 .b8 retval0[1];\r
97 ; CHECK: call.uni (retval0),\r
98 ; CHECK: test_v4i1,\r
99 ; CHECK: ld.param.b8 [[RE0:%rs[0-9]+]], [retval0+0];\r
100 ; CHECK: ld.param.b8 [[RE1:%rs[0-9]+]], [retval0+1];\r
101 ; CHECK: ld.param.b8 [[RE2:%rs[0-9]+]], [retval0+2];\r
102 ; CHECK: ld.param.b8 [[RE3:%rs[0-9]+]], [retval0+3];\r
103 ; CHECK: st.param.b8 [func_retval0+0], [[RE0]];\r
104 ; CHECK: st.param.b8 [func_retval0+1], [[RE1]];\r
105 ; CHECK: st.param.b8 [func_retval0+2], [[RE2]];\r
106 ; CHECK: st.param.b8 [func_retval0+3], [[RE3]];\r
107 ; CHECK-NEXT: ret;\r
108 define <4 x i1> @test_v4i1(<4 x i1> %a) {\r
109 %r = tail call <4 x i1> @test_v4i1(<4 x i1> %a);\r
110 ret <4 x i1> %r;\r
111 }\r
112 \r
113 ; CHECK: .func (.param .align 1 .b8 func_retval0[1])\r
114 ; CHECK-LABEL: test_v5i1(\r
115 ; CHECK-NEXT: .param .align 1 .b8 test_v5i1_param_0[1]\r
116 ; CHECK-DAG: ld.param.u8 [[E4:%rs[0-9]+]], [test_v5i1_param_0+4];\r
117 ; CHECK-DAG: ld.param.u8 [[E0:%rs[0-9]+]], [test_v5i1_param_0]\r
118 ; CHECK: .param .align 1 .b8 param0[1];\r
119 ; CHECK-DAG: st.param.b8 [param0+0], [[E0]];\r
120 ; CHECK-DAG: st.param.b8 [param0+4], [[E4]];\r
121 ; CHECK: .param .align 1 .b8 retval0[1];\r
122 ; CHECK: call.uni (retval0),\r
123 ; CHECK-NEXT: test_v5i1,\r
124 ; CHECK-DAG: ld.param.b8 [[RE0:%rs[0-9]+]], [retval0+0];\r
125 ; CHECK-DAG: ld.param.b8 [[RE4:%rs[0-9]+]], [retval0+4];\r
126 ; CHECK-DAG: st.param.b8 [func_retval0+0], [[RE0]]\r
127 ; CHECK-DAG: st.param.b8 [func_retval0+4], [[RE4]];\r
128 ; CHECK-NEXT: ret;\r
129 define <5 x i1> @test_v5i1(<5 x i1> %a) {\r
130 %r = tail call <5 x i1> @test_v5i1(<5 x i1> %a);\r
131 ret <5 x i1> %r;\r
132 }\r
133 \r
134 ; Unsigned i8 is loaded directly into 32-bit register.\r
135 ; CHECK: .func (.param .b32 func_retval0)\r
136 ; CHECK-LABEL: test_i8(\r
137 ; CHECK-NEXT: .param .b32 test_i8_param_0\r
138 ; CHECK: ld.param.u8 [[A8:%rs[0-9]+]], [test_i8_param_0];\r
139 ; CHECK: cvt.u32.u16 [[A32:%r[0-9]+]], [[A8]];\r
140 ; CHECK: and.b32 [[A:%r[0-9]+]], [[A32]], 255;\r
141 ; CHECK: .param .b32 param0;\r
142 ; CHECK: st.param.b32 [param0+0], [[A]];\r
143 ; CHECK: .param .b32 retval0;\r
144 ; CHECK: call.uni (retval0),\r
145 ; CHECK: test_i8,\r
146 ; CHECK: ld.param.b32 [[R32:%r[0-9]+]], [retval0+0];\r
147 ; CHECK: and.b32 [[R:%r[0-9]+]], [[R32]], 255;\r
148 ; CHECK: st.param.b32 [func_retval0+0], [[R]];\r
149 ; CHECK-NEXT: ret;\r
150 define i8 @test_i8(i8 %a) {\r
151 %r = tail call i8 @test_i8(i8 %a);\r
152 ret i8 %r;\r
153 }\r
154 \r
155 ; signed i8 is loaded into 16-bit register which is then sign-extended to i32.\r
156 ; CHECK: .func (.param .b32 func_retval0)\r
157 ; CHECK-LABEL: test_i8s(\r
158 ; CHECK-NEXT: .param .b32 test_i8s_param_0\r
159 ; CHECK: ld.param.s8 [[A8:%rs[0-9]+]], [test_i8s_param_0];\r
160 ; CHECK: cvt.s32.s16 [[A:%r[0-9]+]], [[A8]];\r
161 ; CHECK: .param .b32 param0;\r
162 ; CHECK: st.param.b32 [param0+0], [[A]];\r
163 ; CHECK: .param .b32 retval0;\r
164 ; CHECK: call.uni (retval0),\r
165 ; CHECK: test_i8s,\r
166 ; CHECK: ld.param.b32 [[R32:%r[0-9]+]], [retval0+0];\r
167 ; -- This is suspicious (though correct) -- why not cvt.u8.u32, cvt.s8.s32 ?\r
168 ; CHECK: cvt.u16.u32 [[R16:%rs[0-9]+]], [[R32]];\r
169 ; CHECK: cvt.s32.s16 [[R:%r[0-9]+]], [[R16]];\r
170 ; CHECK: st.param.b32 [func_retval0+0], [[R]];\r
171 ; CHECK-NEXT: ret;\r
172 define signext i8 @test_i8s(i8 signext %a) {\r
173 %r = tail call signext i8 @test_i8s(i8 signext %a);\r
174 ret i8 %r;\r
175 }\r
176 \r
177 ; CHECK: .func (.param .align 4 .b8 func_retval0[4])\r
178 ; CHECK-LABEL: test_v3i8(\r
179 ; CHECK-NEXT: .param .align 4 .b8 test_v3i8_param_0[4]\r
180 ; CHECK-DAG: ld.param.u8 [[E2:%rs[0-9]+]], [test_v3i8_param_0+2];\r
181 ; CHECK-DAG: ld.param.v2.u8 {[[E0:%rs[0-9]+]], [[E1:%rs[0-9]+]]}, [test_v3i8_param_0];\r
182 ; CHECK: .param .align 4 .b8 param0[4];\r
183 ; CHECK: st.param.v2.b8 [param0+0], {[[E0]], [[E1]]};\r
184 ; CHECK: st.param.b8 [param0+2], [[E2]];\r
185 ; CHECK: .param .align 4 .b8 retval0[4];\r
186 ; CHECK: call.uni (retval0),\r
187 ; CHECK-NEXT: test_v3i8,\r
188 ; CHECK-DAG: ld.param.v2.b8 {[[RE0:%rs[0-9]+]], [[RE1:%rs[0-9]+]]}, [retval0+0];\r
189 ; CHECK-DAG: ld.param.b8 [[RE2:%rs[0-9]+]], [retval0+2];\r
190 ; CHECK-DAG: st.param.v2.b8 [func_retval0+0], {[[RE0]], [[RE1]]};\r
191 ; CHECK-DAG: st.param.b8 [func_retval0+2], [[RE2]];\r
192 ; CHECK-NEXT: ret;\r
193 define <3 x i8> @test_v3i8(<3 x i8> %a) {\r
194 %r = tail call <3 x i8> @test_v3i8(<3 x i8> %a);\r
195 ret <3 x i8> %r;\r
196 }\r
197 \r
198 ; CHECK: .func (.param .align 4 .b8 func_retval0[4])\r
199 ; CHECK-LABEL: test_v4i8(\r
200 ; CHECK-NEXT: .param .align 4 .b8 test_v4i8_param_0[4]\r
201 ; CHECK: ld.param.v4.u8 {[[E0:%rs[0-9]+]], [[E1:%rs[0-9]+]], [[E2:%rs[0-9]+]], [[E3:%rs[0-9]+]]}, [test_v4i8_param_0]\r
202 ; CHECK: .param .align 4 .b8 param0[4];\r
203 ; CHECK: st.param.v4.b8 [param0+0], {[[E0]], [[E1]], [[E2]], [[E3]]};\r
204 ; CHECK: .param .align 4 .b8 retval0[4];\r
205 ; CHECK: call.uni (retval0),\r
206 ; CHECK-NEXT: test_v4i8,\r
207 ; CHECK: ld.param.v4.b8 {[[RE0:%rs[0-9]+]], [[RE1:%rs[0-9]+]], [[RE2:%rs[0-9]+]], [[RE3:%rs[0-9]+]]}, [retval0+0];\r
208 ; CHECK: st.param.v4.b8 [func_retval0+0], {[[RE0]], [[RE1]], [[RE2]], [[RE3]]}\r
209 ; CHECK-NEXT: ret;\r
210 define <4 x i8> @test_v4i8(<4 x i8> %a) {\r
211 %r = tail call <4 x i8> @test_v4i8(<4 x i8> %a);\r
212 ret <4 x i8> %r;\r
213 }\r
214 \r
215 ; CHECK: .func (.param .align 8 .b8 func_retval0[8])\r
216 ; CHECK-LABEL: test_v5i8(\r
217 ; CHECK-NEXT: .param .align 8 .b8 test_v5i8_param_0[8]\r
218 ; CHECK-DAG: ld.param.u8 [[E4:%rs[0-9]+]], [test_v5i8_param_0+4];\r
219 ; CHECK-DAG: ld.param.v4.u8 {[[E0:%rs[0-9]+]], [[E1:%rs[0-9]+]], [[E2:%rs[0-9]+]], [[E3:%rs[0-9]+]]}, [test_v5i8_param_0]\r
220 ; CHECK: .param .align 8 .b8 param0[8];\r
221 ; CHECK-DAG: st.param.v4.b8 [param0+0], {[[E0]], [[E1]], [[E2]], [[E3]]};\r
222 ; CHECK-DAG: st.param.b8 [param0+4], [[E4]];\r
223 ; CHECK: .param .align 8 .b8 retval0[8];\r
224 ; CHECK: call.uni (retval0),\r
225 ; CHECK-NEXT: test_v5i8,\r
226 ; CHECK-DAG: ld.param.v4.b8 {[[RE0:%rs[0-9]+]], [[RE1:%rs[0-9]+]], [[RE2:%rs[0-9]+]], [[RE3:%rs[0-9]+]]}, [retval0+0];\r
227 ; CHECK-DAG: ld.param.b8 [[RE4:%rs[0-9]+]], [retval0+4];\r
228 ; CHECK-DAG: st.param.v4.b8 [func_retval0+0], {[[RE0]], [[RE1]], [[RE2]], [[RE3]]}\r
229 ; CHECK-DAG: st.param.b8 [func_retval0+4], [[RE4]];\r
230 ; CHECK-NEXT: ret;\r
231 define <5 x i8> @test_v5i8(<5 x i8> %a) {\r
232 %r = tail call <5 x i8> @test_v5i8(<5 x i8> %a);\r
233 ret <5 x i8> %r;\r
234 }\r
235 \r
236 ; CHECK: .func (.param .b32 func_retval0)\r
237 ; CHECK-LABEL: test_i16(\r
238 ; CHECK-NEXT: .param .b32 test_i16_param_0\r
239 ; CHECK: ld.param.u16 [[E16:%rs[0-9]+]], [test_i16_param_0];\r
240 ; CHECK: cvt.u32.u16 [[E32:%r[0-9]+]], [[E16]];\r
241 ; CHECK: .param .b32 param0;\r
242 ; CHECK: st.param.b32 [param0+0], [[E32]];\r
243 ; CHECK: .param .b32 retval0;\r
244 ; CHECK: call.uni (retval0),\r
245 ; CHECK-NEXT: test_i16,\r
246 ; CHECK: ld.param.b32 [[RE32:%r[0-9]+]], [retval0+0];\r
247 ; CHECK: and.b32 [[R:%r[0-9]+]], [[RE32]], 65535;\r
248 ; CHECK: st.param.b32 [func_retval0+0], [[R]];\r
249 ; CHECK-NEXT: ret;\r
250 define i16 @test_i16(i16 %a) {\r
251 %r = tail call i16 @test_i16(i16 %a);\r
252 ret i16 %r;\r
253 }\r
254 \r
255 ; CHECK: .func (.param .b32 func_retval0)\r
256 ; CHECK-LABEL: test_i16s(\r
257 ; CHECK-NEXT: .param .b32 test_i16s_param_0\r
258 ; CHECK: ld.param.u16 [[E16:%rs[0-9]+]], [test_i16s_param_0];\r
259 ; CHECK: cvt.s32.s16 [[E32:%r[0-9]+]], [[E16]];\r
260 ; CHECK: .param .b32 param0;\r
261 ; CHECK: st.param.b32 [param0+0], [[E32]];\r
262 ; CHECK: .param .b32 retval0;\r
263 ; CHECK: call.uni (retval0),\r
264 ; CHECK-NEXT: test_i16s,\r
265 ; CHECK: ld.param.b32 [[RE32:%r[0-9]+]], [retval0+0];\r
266 ; CHECK: cvt.s32.s16 [[R:%r[0-9]+]], [[RE32]];\r
267 ; CHECK: st.param.b32 [func_retval0+0], [[R]];\r
268 ; CHECK-NEXT: ret;\r
269 define signext i16 @test_i16s(i16 signext %a) {\r
270 %r = tail call signext i16 @test_i16s(i16 signext %a);\r
271 ret i16 %r;\r
272 }\r
273 \r
274 ; CHECK: .func (.param .align 8 .b8 func_retval0[8])\r
275 ; CHECK-LABEL: test_v3i16(\r
276 ; CHECK-NEXT: .param .align 8 .b8 test_v3i16_param_0[8]\r
277 ; CHECK-DAG: ld.param.u16 [[E2:%rs[0-9]+]], [test_v3i16_param_0+4];\r
278 ; CHECK-DAG: ld.param.v2.u16 {[[E0:%rs[0-9]+]], [[E1:%rs[0-9]+]]}, [test_v3i16_param_0];\r
279 ; CHECK: .param .align 8 .b8 param0[8];\r
280 ; CHECK: st.param.v2.b16 [param0+0], {[[E0]], [[E1]]};\r
281 ; CHECK: st.param.b16 [param0+4], [[E2]];\r
282 ; CHECK: .param .align 8 .b8 retval0[8];\r
283 ; CHECK: call.uni (retval0),\r
284 ; CHECK-NEXT: test_v3i16,\r
285 ; CHECK: ld.param.v2.b16 {[[RE0:%rs[0-9]+]], [[RE1:%rs[0-9]+]]}, [retval0+0];\r
286 ; CHECK: ld.param.b16 [[RE2:%rs[0-9]+]], [retval0+4];\r
287 ; CHECK-DAG: st.param.v2.b16 [func_retval0+0], {[[RE0]], [[RE1]]};\r
288 ; CHECK-DAG: st.param.b16 [func_retval0+4], [[RE2]];\r
289 ; CHECK-NEXT: ret;\r
290 define <3 x i16> @test_v3i16(<3 x i16> %a) {\r
291 %r = tail call <3 x i16> @test_v3i16(<3 x i16> %a);\r
292 ret <3 x i16> %r;\r
293 }\r
294 \r
295 ; CHECK: .func (.param .align 8 .b8 func_retval0[8])\r
296 ; CHECK-LABEL: test_v4i16(\r
297 ; CHECK-NEXT: .param .align 8 .b8 test_v4i16_param_0[8]\r
298 ; CHECK: ld.param.v4.u16 {[[E0:%rs[0-9]+]], [[E1:%rs[0-9]+]], [[E2:%rs[0-9]+]], [[E3:%rs[0-9]+]]}, [test_v4i16_param_0]\r
299 ; CHECK: .param .align 8 .b8 param0[8];\r
300 ; CHECK: st.param.v4.b16 [param0+0], {[[E0]], [[E1]], [[E2]], [[E3]]};\r
301 ; CHECK: .param .align 8 .b8 retval0[8];\r
302 ; CHECK: call.uni (retval0),\r
303 ; CHECK-NEXT: test_v4i16,\r
304 ; CHECK: ld.param.v4.b16 {[[RE0:%rs[0-9]+]], [[RE1:%rs[0-9]+]], [[RE2:%rs[0-9]+]], [[RE3:%rs[0-9]+]]}, [retval0+0];\r
305 ; CHECK: st.param.v4.b16 [func_retval0+0], {[[RE0]], [[RE1]], [[RE2]], [[RE3]]}\r
306 ; CHECK-NEXT: ret;\r
307 define <4 x i16> @test_v4i16(<4 x i16> %a) {\r
308 %r = tail call <4 x i16> @test_v4i16(<4 x i16> %a);\r
309 ret <4 x i16> %r;\r
310 }\r
311 \r
312 ; CHECK: .func (.param .align 16 .b8 func_retval0[16])\r
313 ; CHECK-LABEL: test_v5i16(\r
314 ; CHECK-NEXT: .param .align 16 .b8 test_v5i16_param_0[16]\r
315 ; CHECK-DAG: ld.param.u16 [[E4:%rs[0-9]+]], [test_v5i16_param_0+8];\r
316 ; CHECK-DAG: ld.param.v4.u16 {[[E0:%rs[0-9]+]], [[E1:%rs[0-9]+]], [[E2:%rs[0-9]+]], [[E3:%rs[0-9]+]]}, [test_v5i16_param_0]\r
317 ; CHECK: .param .align 16 .b8 param0[16];\r
318 ; CHECK-DAG: st.param.v4.b16 [param0+0], {[[E0]], [[E1]], [[E2]], [[E3]]};\r
319 ; CHECK-DAG: st.param.b16 [param0+8], [[E4]];\r
320 ; CHECK: .param .align 16 .b8 retval0[16];\r
321 ; CHECK: call.uni (retval0),\r
322 ; CHECK-NEXT: test_v5i16,\r
323 ; CHECK-DAG: ld.param.v4.b16 {[[RE0:%rs[0-9]+]], [[RE1:%rs[0-9]+]], [[RE2:%rs[0-9]+]], [[RE3:%rs[0-9]+]]}, [retval0+0];\r
324 ; CHECK-DAG: ld.param.b16 [[RE4:%rs[0-9]+]], [retval0+8];\r
325 ; CHECK-DAG: st.param.v4.b16 [func_retval0+0], {[[RE0]], [[RE1]], [[RE2]], [[RE3]]}\r
326 ; CHECK-DAG: st.param.b16 [func_retval0+8], [[RE4]];\r
327 ; CHECK-NEXT: ret;\r
328 define <5 x i16> @test_v5i16(<5 x i16> %a) {\r
329 %r = tail call <5 x i16> @test_v5i16(<5 x i16> %a);\r
330 ret <5 x i16> %r;\r
331 }\r
332 \r
333 ; CHECK: .func (.param .b32 func_retval0)\r
334 ; CHECK-LABEL: test_f16(\r
335 ; CHECK-NEXT: .param .b32 test_f16_param_0\r
336 ; CHECK: ld.param.b16 [[E:%h[0-9]+]], [test_f16_param_0];\r
337 ; CHECK: .param .b32 param0;\r
338 ; CHECK: st.param.b16 [param0+0], [[E]];\r
339 ; CHECK: .param .b32 retval0;\r
340 ; CHECK: call.uni (retval0),\r
341 ; CHECK-NEXT: test_f16,\r
342 ; CHECK: ld.param.b16 [[R:%h[0-9]+]], [retval0+0];\r
343 ; CHECK: st.param.b16 [func_retval0+0], [[R]]\r
344 ; CHECK-NEXT: ret;\r
345 define half @test_f16(half %a) {\r
346 %r = tail call half @test_f16(half %a);\r
347 ret half %r;\r
348 }\r
349 \r
350 ; CHECK: .func (.param .align 4 .b8 func_retval0[4])\r
351 ; CHECK-LABEL: test_v2f16(\r
352 ; CHECK-NEXT: .param .align 4 .b8 test_v2f16_param_0[4]\r
353 ; CHECK: ld.param.b32 [[E:%hh[0-9]+]], [test_v2f16_param_0];\r
354 ; CHECK: .param .align 4 .b8 param0[4];\r
355 ; CHECK: st.param.b32 [param0+0], [[E]];\r
356 ; CHECK: .param .align 4 .b8 retval0[4];\r
357 ; CHECK: call.uni (retval0),\r
358 ; CHECK-NEXT: test_v2f16,\r
359 ; CHECK: ld.param.b32 [[R:%hh[0-9]+]], [retval0+0];\r
360 ; CHECK: st.param.b32 [func_retval0+0], [[R]]\r
361 ; CHECK-NEXT: ret;\r
362 define <2 x half> @test_v2f16(<2 x half> %a) {\r
363 %r = tail call <2 x half> @test_v2f16(<2 x half> %a);\r
364 ret <2 x half> %r;\r
365 }\r
366 \r
367 ; CHECK:.func (.param .align 8 .b8 func_retval0[8])\r
368 ; CHECK-LABEL: test_v3f16(\r
369 ; CHECK: .param .align 8 .b8 test_v3f16_param_0[8]\r
370 ; CHECK-DAG: ld.param.b32 [[HH01:%hh[0-9]+]], [test_v3f16_param_0];\r
371 ; CHECK-DAG: mov.b32 {[[E0:%h[0-9]+]], [[E1:%h[0-9]+]]}, [[HH01]];\r
372 ; CHECK-DAG: ld.param.b16 [[E2:%h[0-9]+]], [test_v3f16_param_0+4];\r
373 ; CHECK: .param .align 8 .b8 param0[8];\r
374 ; CHECK-DAG: st.param.v2.b16 [param0+0], {[[E0]], [[E1]]};\r
375 ; CHECK-DAG: st.param.b16 [param0+4], [[E2]];\r
376 ; CHECK: .param .align 8 .b8 retval0[8];\r
377 ; CHECK: call.uni (retval0),\r
378 ; CHECK: test_v3f16,\r
379 ; CHECK-DAG: ld.param.v2.b16 {[[R0:%h[0-9]+]], [[R1:%h[0-9]+]]}, [retval0+0];\r
380 ; CHECK-DAG: ld.param.b16 [[R2:%h[0-9]+]], [retval0+4];\r
381 ; CHECK-DAG: st.param.v2.b16 [func_retval0+0], {[[R0]], [[R1]]};\r
382 ; CHECK-DAG: st.param.b16 [func_retval0+4], [[R2]];\r
383 ; CHECK: ret;\r
384 define <3 x half> @test_v3f16(<3 x half> %a) {\r
385 %r = tail call <3 x half> @test_v3f16(<3 x half> %a);\r
386 ret <3 x half> %r;\r
387 }\r
388 \r
389 ; CHECK:.func (.param .align 8 .b8 func_retval0[8])\r
390 ; CHECK-LABEL: test_v4f16(\r
391 ; CHECK: .param .align 8 .b8 test_v4f16_param_0[8]\r
392 ; CHECK: ld.param.v2.u32 {[[R01:%r[0-9]+]], [[R23:%r[0-9]+]]}, [test_v4f16_param_0];\r
393 ; CHECK-DAG: mov.b32 [[HH01:%hh[0-9]+]], [[R01]];\r
394 ; CHECK-DAG: mov.b32 [[HH23:%hh[0-9]+]], [[R23]];\r
395 ; CHECK: .param .align 8 .b8 param0[8];\r
396 ; CHECK: st.param.v2.b32 [param0+0], {[[HH01]], [[HH23]]};\r
397 ; CHECK: .param .align 8 .b8 retval0[8];\r
398 ; CHECK: call.uni (retval0),\r
399 ; CHECK: test_v4f16,\r
400 ; CHECK: ld.param.v2.b32 {[[RH01:%hh[0-9]+]], [[RH23:%hh[0-9]+]]}, [retval0+0];\r
401 ; CHECK: st.param.v2.b32 [func_retval0+0], {[[RH01]], [[RH23]]};\r
402 ; CHECK: ret;\r
403 define <4 x half> @test_v4f16(<4 x half> %a) {\r
404 %r = tail call <4 x half> @test_v4f16(<4 x half> %a);\r
405 ret <4 x half> %r;\r
406 }\r
407 \r
408 ; CHECK:.func (.param .align 16 .b8 func_retval0[16])\r
409 ; CHECK-LABEL: test_v5f16(\r
410 ; CHECK: .param .align 16 .b8 test_v5f16_param_0[16]\r
411 ; CHECK-DAG: ld.param.v4.b16 {[[E0:%h[0-9]+]], [[E1:%h[0-9]+]], [[E2:%h[0-9]+]], [[E3:%h[0-9]+]]}, [test_v5f16_param_0];\r
412 ; CHECK-DAG: mov.b32 {[[E0:%h[0-9]+]], [[E1:%h[0-9]+]]}, [[HH01]];\r
413 ; CHECK-DAG: ld.param.b16 [[E4:%h[0-9]+]], [test_v5f16_param_0+8];\r
414 ; CHECK: .param .align 16 .b8 param0[16];\r
415 ; CHECK-DAG: st.param.v4.b16 [param0+0],\r
416 ; CHECK-DAG: st.param.b16 [param0+8], [[E4]];\r
417 ; CHECK: .param .align 16 .b8 retval0[16];\r
418 ; CHECK: call.uni (retval0),\r
419 ; CHECK: test_v5f16,\r
420 ; CHECK-DAG: ld.param.v4.b16 {[[R0:%h[0-9]+]], [[R1:%h[0-9]+]], [[R2:%h[0-9]+]], [[R3:%h[0-9]+]]}, [retval0+0];\r
421 ; CHECK-DAG: ld.param.b16 [[R4:%h[0-9]+]], [retval0+8];\r
422 ; CHECK-DAG: st.param.v4.b16 [func_retval0+0], {[[R0]], [[R1]], [[R2]], [[R3]]};\r
423 ; CHECK-DAG: st.param.b16 [func_retval0+8], [[R4]];\r
424 ; CHECK: ret;\r
425 define <5 x half> @test_v5f16(<5 x half> %a) {\r
426 %r = tail call <5 x half> @test_v5f16(<5 x half> %a);\r
427 ret <5 x half> %r;\r
428 }\r
429 \r
430 ; CHECK:.func (.param .align 16 .b8 func_retval0[16])\r
431 ; CHECK-LABEL: test_v8f16(\r
432 ; CHECK: .param .align 16 .b8 test_v8f16_param_0[16]\r
433 ; CHECK: ld.param.v4.u32 {[[R01:%r[0-9]+]], [[R23:%r[0-9]+]], [[R45:%r[0-9]+]], [[R67:%r[0-9]+]]}, [test_v8f16_param_0];\r
434 ; CHECK-DAG: mov.b32 [[HH01:%hh[0-9]+]], [[R01]];\r
435 ; CHECK-DAG: mov.b32 [[HH23:%hh[0-9]+]], [[R23]];\r
436 ; CHECK-DAG: mov.b32 [[HH45:%hh[0-9]+]], [[R45]];\r
437 ; CHECK-DAG: mov.b32 [[HH67:%hh[0-9]+]], [[R67]];\r
438 ; CHECK: .param .align 16 .b8 param0[16];\r
439 ; CHECK: st.param.v4.b32 [param0+0], {[[HH01]], [[HH23]], [[HH45]], [[HH67]]};\r
440 ; CHECK: .param .align 16 .b8 retval0[16];\r
441 ; CHECK: call.uni (retval0),\r
442 ; CHECK: test_v8f16,\r
443 ; CHECK: ld.param.v4.b32 {[[RH01:%hh[0-9]+]], [[RH23:%hh[0-9]+]], [[RH45:%hh[0-9]+]], [[RH67:%hh[0-9]+]]}, [retval0+0];\r
444 ; CHECK: st.param.v4.b32 [func_retval0+0], {[[RH01]], [[RH23]], [[RH45]], [[RH67]]};\r
445 ; CHECK: ret;\r
446 define <8 x half> @test_v8f16(<8 x half> %a) {\r
447 %r = tail call <8 x half> @test_v8f16(<8 x half> %a);\r
448 ret <8 x half> %r;\r
449 }\r
450 \r
451 ; CHECK:.func (.param .align 32 .b8 func_retval0[32])\r
452 ; CHECK-LABEL: test_v9f16(\r
453 ; CHECK: .param .align 32 .b8 test_v9f16_param_0[32]\r
454 ; CHECK-DAG: ld.param.v4.b16 {[[E0:%h[0-9]+]], [[E1:%h[0-9]+]], [[E2:%h[0-9]+]], [[E3:%h[0-9]+]]}, [test_v9f16_param_0];\r
455 ; CHECK-DAG: ld.param.v4.b16 {[[E4:%h[0-9]+]], [[E5:%h[0-9]+]], [[E6:%h[0-9]+]], [[E7:%h[0-9]+]]}, [test_v9f16_param_0+8];\r
456 ; CHECK-DAG: ld.param.b16 [[E8:%h[0-9]+]], [test_v9f16_param_0+16];\r
457 ; CHECK: .param .align 32 .b8 param0[32];\r
458 ; CHECK-DAG: st.param.v4.b16 [param0+0],\r
459 ; CHECK-DAG: st.param.v4.b16 [param0+8],\r
460 ; CHECK-DAG: st.param.b16 [param0+16], [[E8]];\r
461 ; CHECK: .param .align 32 .b8 retval0[32];\r
462 ; CHECK: call.uni (retval0),\r
463 ; CHECK: test_v9f16,\r
464 ; CHECK-DAG: ld.param.v4.b16 {[[R0:%h[0-9]+]], [[R1:%h[0-9]+]], [[R2:%h[0-9]+]], [[R3:%h[0-9]+]]}, [retval0+0];\r
465 ; CHECK-DAG: ld.param.v4.b16 {[[R4:%h[0-9]+]], [[R5:%h[0-9]+]], [[R6:%h[0-9]+]], [[R7:%h[0-9]+]]}, [retval0+8];\r
466 ; CHECK-DAG: ld.param.b16 [[R8:%h[0-9]+]], [retval0+16];\r
467 ; CHECK-DAG: st.param.v4.b16 [func_retval0+0], {[[R0]], [[R1]], [[R2]], [[R3]]};\r
468 ; CHECK-DAG: st.param.v4.b16 [func_retval0+8], {[[R4]], [[R5]], [[R6]], [[R7]]};\r
469 ; CHECK-DAG: st.param.b16 [func_retval0+16], [[R8]];\r
470 ; CHECK: ret;\r
471 define <9 x half> @test_v9f16(<9 x half> %a) {\r
472 %r = tail call <9 x half> @test_v9f16(<9 x half> %a);\r
473 ret <9 x half> %r;\r
474 }\r
475 \r
476 ; CHECK: .func (.param .b32 func_retval0)\r
477 ; CHECK-LABEL: test_i32(\r
478 ; CHECK-NEXT: .param .b32 test_i32_param_0\r
479 ; CHECK: ld.param.u32 [[E:%r[0-9]+]], [test_i32_param_0];\r
480 ; CHECK: .param .b32 param0;\r
481 ; CHECK: st.param.b32 [param0+0], [[E]];\r
482 ; CHECK: .param .b32 retval0;\r
483 ; CHECK: call.uni (retval0),\r
484 ; CHECK-NEXT: test_i32,\r
485 ; CHECK: ld.param.b32 [[R:%r[0-9]+]], [retval0+0];\r
486 ; CHECK: st.param.b32 [func_retval0+0], [[R]];\r
487 ; CHECK-NEXT: ret;\r
488 define i32 @test_i32(i32 %a) {\r
489 %r = tail call i32 @test_i32(i32 %a);\r
490 ret i32 %r;\r
491 }\r
492 \r
493 ; CHECK: .func (.param .align 16 .b8 func_retval0[16])\r
494 ; CHECK-LABEL: test_v3i32(\r
495 ; CHECK-NEXT: .param .align 16 .b8 test_v3i32_param_0[16]\r
496 ; CHECK-DAG: ld.param.u32 [[E2:%r[0-9]+]], [test_v3i32_param_0+8];\r
497 ; CHECK-DAG: ld.param.v2.u32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_v3i32_param_0];\r
498 ; CHECK: .param .align 16 .b8 param0[16];\r
499 ; CHECK: st.param.v2.b32 [param0+0], {[[E0]], [[E1]]};\r
500 ; CHECK: st.param.b32 [param0+8], [[E2]];\r
501 ; CHECK: .param .align 16 .b8 retval0[16];\r
502 ; CHECK: call.uni (retval0),\r
503 ; CHECK-NEXT: test_v3i32,\r
504 ; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0+0];\r
505 ; CHECK: ld.param.b32 [[RE2:%r[0-9]+]], [retval0+8];\r
506 ; CHECK-DAG: st.param.v2.b32 [func_retval0+0], {[[RE0]], [[RE1]]};\r
507 ; CHECK-DAG: st.param.b32 [func_retval0+8], [[RE2]];\r
508 ; CHECK-NEXT: ret;\r
509 define <3 x i32> @test_v3i32(<3 x i32> %a) {\r
510 %r = tail call <3 x i32> @test_v3i32(<3 x i32> %a);\r
511 ret <3 x i32> %r;\r
512 }\r
513 \r
514 ; CHECK: .func (.param .align 16 .b8 func_retval0[16])\r
515 ; CHECK-LABEL: test_v4i32(\r
516 ; CHECK-NEXT: .param .align 16 .b8 test_v4i32_param_0[16]\r
517 ; CHECK: ld.param.v4.u32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]], [[E2:%r[0-9]+]], [[E3:%r[0-9]+]]}, [test_v4i32_param_0]\r
518 ; CHECK: .param .align 16 .b8 param0[16];\r
519 ; CHECK: st.param.v4.b32 [param0+0], {[[E0]], [[E1]], [[E2]], [[E3]]};\r
520 ; CHECK: .param .align 16 .b8 retval0[16];\r
521 ; CHECK: call.uni (retval0),\r
522 ; CHECK-NEXT: test_v4i32,\r
523 ; CHECK: ld.param.v4.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]], [[RE2:%r[0-9]+]], [[RE3:%r[0-9]+]]}, [retval0+0];\r
524 ; CHECK: st.param.v4.b32 [func_retval0+0], {[[RE0]], [[RE1]], [[RE2]], [[RE3]]}\r
525 ; CHECK-NEXT: ret;\r
526 define <4 x i32> @test_v4i32(<4 x i32> %a) {\r
527 %r = tail call <4 x i32> @test_v4i32(<4 x i32> %a);\r
528 ret <4 x i32> %r;\r
529 }\r
530 \r
531 ; CHECK: .func (.param .align 32 .b8 func_retval0[32])\r
532 ; CHECK-LABEL: test_v5i32(\r
533 ; CHECK-NEXT: .param .align 32 .b8 test_v5i32_param_0[32]\r
534 ; CHECK-DAG: ld.param.u32 [[E4:%r[0-9]+]], [test_v5i32_param_0+16];\r
535 ; CHECK-DAG: ld.param.v4.u32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]], [[E2:%r[0-9]+]], [[E3:%r[0-9]+]]}, [test_v5i32_param_0]\r
536 ; CHECK: .param .align 32 .b8 param0[32];\r
537 ; CHECK-DAG: st.param.v4.b32 [param0+0], {[[E0]], [[E1]], [[E2]], [[E3]]};\r
538 ; CHECK-DAG: st.param.b32 [param0+16], [[E4]];\r
539 ; CHECK: .param .align 32 .b8 retval0[32];\r
540 ; CHECK: call.uni (retval0),\r
541 ; CHECK-NEXT: test_v5i32,\r
542 ; CHECK-DAG: ld.param.v4.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]], [[RE2:%r[0-9]+]], [[RE3:%r[0-9]+]]}, [retval0+0];\r
543 ; CHECK-DAG: ld.param.b32 [[RE4:%r[0-9]+]], [retval0+16];\r
544 ; CHECK-DAG: st.param.v4.b32 [func_retval0+0], {[[RE0]], [[RE1]], [[RE2]], [[RE3]]}\r
545 ; CHECK-DAG: st.param.b32 [func_retval0+16], [[RE4]];\r
546 ; CHECK-NEXT: ret;\r
547 define <5 x i32> @test_v5i32(<5 x i32> %a) {\r
548 %r = tail call <5 x i32> @test_v5i32(<5 x i32> %a);\r
549 ret <5 x i32> %r;\r
550 }\r
551 \r
552 ; CHECK: .func (.param .b32 func_retval0)\r
553 ; CHECK-LABEL: test_f32(\r
554 ; CHECK-NEXT: .param .b32 test_f32_param_0\r
555 ; CHECK: ld.param.f32 [[E:%f[0-9]+]], [test_f32_param_0];\r
556 ; CHECK: .param .b32 param0;\r
557 ; CHECK: st.param.f32 [param0+0], [[E]];\r
558 ; CHECK: .param .b32 retval0;\r
559 ; CHECK: call.uni (retval0),\r
560 ; CHECK-NEXT: test_f32,\r
561 ; CHECK: ld.param.f32 [[R:%f[0-9]+]], [retval0+0];\r
562 ; CHECK: st.param.f32 [func_retval0+0], [[R]];\r
563 ; CHECK-NEXT: ret;\r
564 define float @test_f32(float %a) {\r
565 %r = tail call float @test_f32(float %a);\r
566 ret float %r;\r
567 }\r
568 \r
569 ; CHECK: .func (.param .b64 func_retval0)\r
570 ; CHECK-LABEL: test_i64(\r
571 ; CHECK-NEXT: .param .b64 test_i64_param_0\r
572 ; CHECK: ld.param.u64 [[E:%rd[0-9]+]], [test_i64_param_0];\r
573 ; CHECK: .param .b64 param0;\r
574 ; CHECK: st.param.b64 [param0+0], [[E]];\r
575 ; CHECK: .param .b64 retval0;\r
576 ; CHECK: call.uni (retval0),\r
577 ; CHECK-NEXT: test_i64,\r
578 ; CHECK: ld.param.b64 [[R:%rd[0-9]+]], [retval0+0];\r
579 ; CHECK: st.param.b64 [func_retval0+0], [[R]];\r
580 ; CHECK-NEXT: ret;\r
581 define i64 @test_i64(i64 %a) {\r
582 %r = tail call i64 @test_i64(i64 %a);\r
583 ret i64 %r;\r
584 }\r
585 \r
586 ; CHECK: .func (.param .align 32 .b8 func_retval0[32])\r
587 ; CHECK-LABEL: test_v3i64(\r
588 ; CHECK-NEXT: .param .align 32 .b8 test_v3i64_param_0[32]\r
589 ; CHECK-DAG: ld.param.u64 [[E2:%rd[0-9]+]], [test_v3i64_param_0+16];\r
590 ; CHECK-DAG: ld.param.v2.u64 {[[E0:%rd[0-9]+]], [[E1:%rd[0-9]+]]}, [test_v3i64_param_0];\r
591 ; CHECK: .param .align 32 .b8 param0[32];\r
592 ; CHECK: st.param.v2.b64 [param0+0], {[[E0]], [[E1]]};\r
593 ; CHECK: st.param.b64 [param0+16], [[E2]];\r
594 ; CHECK: .param .align 32 .b8 retval0[32];\r
595 ; CHECK: call.uni (retval0),\r
596 ; CHECK-NEXT: test_v3i64,\r
597 ; CHECK: ld.param.v2.b64 {[[RE0:%rd[0-9]+]], [[RE1:%rd[0-9]+]]}, [retval0+0];\r
598 ; CHECK: ld.param.b64 [[RE2:%rd[0-9]+]], [retval0+16];\r
599 ; CHECK-DAG: st.param.v2.b64 [func_retval0+0], {[[RE0]], [[RE1]]};\r
600 ; CHECK-DAG: st.param.b64 [func_retval0+16], [[RE2]];\r
601 ; CHECK-DAG: st.param.v2.b64 [func_retval0+0], {[[RE0]], [[RE1]]};\r
602 ; CHECK-DAG: st.param.b64 [func_retval0+16], [[RE2]];\r
603 ; CHECK-NEXT: ret;\r
604 define <3 x i64> @test_v3i64(<3 x i64> %a) {\r
605 %r = tail call <3 x i64> @test_v3i64(<3 x i64> %a);\r
606 ret <3 x i64> %r;\r
607 }\r
608 \r
609 ; For i64 vector loads are limited by PTX to 2 elements.\r
610 ; CHECK: .func (.param .align 32 .b8 func_retval0[32])\r
611 ; CHECK-LABEL: test_v4i64(\r
612 ; CHECK-NEXT: .param .align 32 .b8 test_v4i64_param_0[32]\r
613 ; CHECK-DAG: ld.param.v2.u64 {[[E2:%rd[0-9]+]], [[E3:%rd[0-9]+]]}, [test_v4i64_param_0+16];\r
614 ; CHECK-DAG: ld.param.v2.u64 {[[E0:%rd[0-9]+]], [[E1:%rd[0-9]+]]}, [test_v4i64_param_0];\r
615 ; CHECK: .param .align 32 .b8 param0[32];\r
616 ; CHECK: st.param.v2.b64 [param0+0], {[[E0]], [[E1]]};\r
617 ; CHECK: st.param.v2.b64 [param0+16], {[[E2]], [[E3]]};\r
618 ; CHECK: .param .align 32 .b8 retval0[32];\r
619 ; CHECK: call.uni (retval0),\r
620 ; CHECK-NEXT: test_v4i64,\r
621 ; CHECK: ld.param.v2.b64 {[[RE0:%rd[0-9]+]], [[RE1:%rd[0-9]+]]}, [retval0+0];\r
622 ; CHECK: ld.param.v2.b64 {[[RE2:%rd[0-9]+]], [[RE3:%rd[0-9]+]]}, [retval0+16];\r
623 ; CHECK-DAG: st.param.v2.b64 [func_retval0+16], {[[RE2]], [[RE3]]};\r
624 ; CHECK-DAG: st.param.v2.b64 [func_retval0+0], {[[RE0]], [[RE1]]};\r
625 ; CHECK-NEXT: ret;\r
626 define <4 x i64> @test_v4i64(<4 x i64> %a) {\r
627 %r = tail call <4 x i64> @test_v4i64(<4 x i64> %a);\r
628 ret <4 x i64> %r;\r
629 }\r
630 \r
631 ; Aggregates, on the other hand, do not get extended.\r
632 \r
633 ; CHECK: .func (.param .align 1 .b8 func_retval0[1])\r
634 ; CHECK-LABEL: test_s_i1(\r
635 ; CHECK-NEXT: .align 1 .b8 test_s_i1_param_0[1]\r
636 ; CHECK: ld.param.u8 [[A:%rs[0-9]+]], [test_s_i1_param_0];\r
637 ; CHECK: .param .align 1 .b8 param0[1];\r
638 ; CHECK: st.param.b8 [param0+0], [[A]]\r
639 ; CHECK: .param .align 1 .b8 retval0[1];\r
640 ; CHECK: call.uni\r
641 ; CHECK-NEXT: test_s_i1,\r
642 ; CHECK: ld.param.b8 [[R:%rs[0-9]+]], [retval0+0];\r
643 ; CHECK: st.param.b8 [func_retval0+0], [[R]];\r
644 ; CHECK-NEXT: ret;\r
645 define %s_i1 @test_s_i1(%s_i1 %a) {\r
646 %r = tail call %s_i1 @test_s_i1(%s_i1 %a);\r
647 ret %s_i1 %r;\r
648 }\r
649 \r
650 ; CHECK: .func (.param .align 1 .b8 func_retval0[1])\r
651 ; CHECK-LABEL: test_s_i8(\r
652 ; CHECK-NEXT: .param .align 1 .b8 test_s_i8_param_0[1]\r
653 ; CHECK: ld.param.u8 [[A:%rs[0-9]+]], [test_s_i8_param_0];\r
654 ; CHECK: .param .align 1 .b8 param0[1];\r
655 ; CHECK: st.param.b8 [param0+0], [[A]]\r
656 ; CHECK: .param .align 1 .b8 retval0[1];\r
657 ; CHECK: call.uni\r
658 ; CHECK-NEXT: test_s_i8,\r
659 ; CHECK: ld.param.b8 [[R:%rs[0-9]+]], [retval0+0];\r
660 ; CHECK: st.param.b8 [func_retval0+0], [[R]];\r
661 ; CHECK-NEXT: ret;\r
662 define %s_i8 @test_s_i8(%s_i8 %a) {\r
663 %r = tail call %s_i8 @test_s_i8(%s_i8 %a);\r
664 ret %s_i8 %r;\r
665 }\r
666 \r
667 ; CHECK: .func (.param .align 2 .b8 func_retval0[2])\r
668 ; CHECK-LABEL: test_s_i16(\r
669 ; CHECK-NEXT: .param .align 2 .b8 test_s_i16_param_0[2]\r
670 ; CHECK: ld.param.u16 [[A:%rs[0-9]+]], [test_s_i16_param_0];\r
671 ; CHECK: .param .align 2 .b8 param0[2];\r
672 ; CHECK: st.param.b16 [param0+0], [[A]]\r
673 ; CHECK: .param .align 2 .b8 retval0[2];\r
674 ; CHECK: call.uni\r
675 ; CHECK-NEXT: test_s_i16,\r
676 ; CHECK: ld.param.b16 [[R:%rs[0-9]+]], [retval0+0];\r
677 ; CHECK: st.param.b16 [func_retval0+0], [[R]];\r
678 ; CHECK-NEXT: ret;\r
679 define %s_i16 @test_s_i16(%s_i16 %a) {\r
680 %r = tail call %s_i16 @test_s_i16(%s_i16 %a);\r
681 ret %s_i16 %r;\r
682 }\r
683 \r
684 ; CHECK: .func (.param .align 2 .b8 func_retval0[2])\r
685 ; CHECK-LABEL: test_s_f16(\r
686 ; CHECK-NEXT: .param .align 2 .b8 test_s_f16_param_0[2]\r
687 ; CHECK: ld.param.b16 [[A:%h[0-9]+]], [test_s_f16_param_0];\r
688 ; CHECK: .param .align 2 .b8 param0[2];\r
689 ; CHECK: st.param.b16 [param0+0], [[A]]\r
690 ; CHECK: .param .align 2 .b8 retval0[2];\r
691 ; CHECK: call.uni\r
692 ; CHECK-NEXT: test_s_f16,\r
693 ; CHECK: ld.param.b16 [[R:%h[0-9]+]], [retval0+0];\r
694 ; CHECK: st.param.b16 [func_retval0+0], [[R]];\r
695 ; CHECK-NEXT: ret;\r
696 define %s_f16 @test_s_f16(%s_f16 %a) {\r
697 %r = tail call %s_f16 @test_s_f16(%s_f16 %a);\r
698 ret %s_f16 %r;\r
699 }\r
700 \r
701 ; CHECK: .func (.param .align 4 .b8 func_retval0[4])\r
702 ; CHECK-LABEL: test_s_i32(\r
703 ; CHECK-NEXT: .param .align 4 .b8 test_s_i32_param_0[4]\r
704 ; CHECK: ld.param.u32 [[E:%r[0-9]+]], [test_s_i32_param_0];\r
705 ; CHECK: .param .align 4 .b8 param0[4]\r
706 ; CHECK: st.param.b32 [param0+0], [[E]];\r
707 ; CHECK: .param .align 4 .b8 retval0[4];\r
708 ; CHECK: call.uni (retval0),\r
709 ; CHECK-NEXT: test_s_i32,\r
710 ; CHECK: ld.param.b32 [[R:%r[0-9]+]], [retval0+0];\r
711 ; CHECK: st.param.b32 [func_retval0+0], [[R]];\r
712 ; CHECK-NEXT: ret;\r
713 define %s_i32 @test_s_i32(%s_i32 %a) {\r
714 %r = tail call %s_i32 @test_s_i32(%s_i32 %a);\r
715 ret %s_i32 %r;\r
716 }\r
717 \r
718 ; CHECK: .func (.param .align 4 .b8 func_retval0[4])\r
719 ; CHECK-LABEL: test_s_f32(\r
720 ; CHECK-NEXT: .param .align 4 .b8 test_s_f32_param_0[4]\r
721 ; CHECK: ld.param.f32 [[E:%f[0-9]+]], [test_s_f32_param_0];\r
722 ; CHECK: .param .align 4 .b8 param0[4]\r
723 ; CHECK: st.param.f32 [param0+0], [[E]];\r
724 ; CHECK: .param .align 4 .b8 retval0[4];\r
725 ; CHECK: call.uni (retval0),\r
726 ; CHECK-NEXT: test_s_f32,\r
727 ; CHECK: ld.param.f32 [[R:%f[0-9]+]], [retval0+0];\r
728 ; CHECK: st.param.f32 [func_retval0+0], [[R]];\r
729 ; CHECK-NEXT: ret;\r
730 define %s_f32 @test_s_f32(%s_f32 %a) {\r
731 %r = tail call %s_f32 @test_s_f32(%s_f32 %a);\r
732 ret %s_f32 %r;\r
733 }\r
734 \r
735 ; CHECK: .func (.param .align 8 .b8 func_retval0[8])\r
736 ; CHECK-LABEL: test_s_i64(\r
737 ; CHECK-NEXT: .param .align 8 .b8 test_s_i64_param_0[8]\r
738 ; CHECK: ld.param.u64 [[E:%rd[0-9]+]], [test_s_i64_param_0];\r
739 ; CHECK: .param .align 8 .b8 param0[8];\r
740 ; CHECK: st.param.b64 [param0+0], [[E]];\r
741 ; CHECK: .param .align 8 .b8 retval0[8];\r
742 ; CHECK: call.uni (retval0),\r
743 ; CHECK-NEXT: test_s_i64,\r
744 ; CHECK: ld.param.b64 [[R:%rd[0-9]+]], [retval0+0];\r
745 ; CHECK: st.param.b64 [func_retval0+0], [[R]];\r
746 ; CHECK-NEXT: ret;\r
747 define %s_i64 @test_s_i64(%s_i64 %a) {\r
748 %r = tail call %s_i64 @test_s_i64(%s_i64 %a);\r
749 ret %s_i64 %r;\r
750 }\r
751 \r
752 ; Fields that have different types, but identical sizes are not vectorized.\r
753 ; CHECK: .func (.param .align 8 .b8 func_retval0[24])\r
754 ; CHECK-LABEL: test_s_i32f32(\r
755 ; CHECK: .param .align 8 .b8 test_s_i32f32_param_0[24]\r
756 ; CHECK-DAG: ld.param.u64 [[E4:%rd[0-9]+]], [test_s_i32f32_param_0+16];\r
757 ; CHECK-DAG: ld.param.f32 [[E3:%f[0-9]+]], [test_s_i32f32_param_0+12];\r
758 ; CHECK-DAG: ld.param.u32 [[E2:%r[0-9]+]], [test_s_i32f32_param_0+8];\r
759 ; CHECK-DAG: ld.param.f32 [[E1:%f[0-9]+]], [test_s_i32f32_param_0+4];\r
760 ; CHECK-DAG: ld.param.u32 [[E0:%r[0-9]+]], [test_s_i32f32_param_0];\r
761 ; CHECK: .param .align 8 .b8 param0[24];\r
762 ; CHECK-DAG: st.param.b32 [param0+0], [[E0]];\r
763 ; CHECK-DAG: st.param.f32 [param0+4], [[E1]];\r
764 ; CHECK-DAG: st.param.b32 [param0+8], [[E2]];\r
765 ; CHECK-DAG: st.param.f32 [param0+12], [[E3]];\r
766 ; CHECK-DAG: st.param.b64 [param0+16], [[E4]];\r
767 ; CHECK: .param .align 8 .b8 retval0[24];\r
768 ; CHECK: call.uni (retval0),\r
769 ; CHECK-NEXT: test_s_i32f32,\r
770 ; CHECK-DAG: ld.param.b32 [[RE0:%r[0-9]+]], [retval0+0];\r
771 ; CHECK-DAG: ld.param.f32 [[RE1:%f[0-9]+]], [retval0+4];\r
772 ; CHECK-DAG: ld.param.b32 [[RE2:%r[0-9]+]], [retval0+8];\r
773 ; CHECK-DAG: ld.param.f32 [[RE3:%f[0-9]+]], [retval0+12];\r
774 ; CHECK-DAG: ld.param.b64 [[RE4:%rd[0-9]+]], [retval0+16];\r
775 ; CHECK-DAG: st.param.b32 [func_retval0+0], [[RE0]];\r
776 ; CHECK-DAG: st.param.f32 [func_retval0+4], [[RE1]];\r
777 ; CHECK-DAG: st.param.b32 [func_retval0+8], [[RE2]];\r
778 ; CHECK-DAG: st.param.f32 [func_retval0+12], [[RE3]];\r
779 ; CHECK-DAG: st.param.b64 [func_retval0+16], [[RE4]];\r
780 ; CHECK: ret;\r
781 define %s_i32f32 @test_s_i32f32(%s_i32f32 %a) {\r
782 %r = tail call %s_i32f32 @test_s_i32f32(%s_i32f32 %a);\r
783 ret %s_i32f32 %r;\r
784 }\r
785 \r
786 ; We do vectorize consecutive fields with matching types.\r
787 ; CHECK:.visible .func (.param .align 8 .b8 func_retval0[24])\r
788 ; CHECK-LABEL: test_s_i32x4(\r
789 ; CHECK: .param .align 8 .b8 test_s_i32x4_param_0[24]\r
790 ; CHECK-DAG: ld.param.u64 [[RD1:%rd[0-9]+]], [test_s_i32x4_param_0+16];\r
791 ; CHECK-DAG: ld.param.v2.u32 {[[E2:%r[0-9]+]], [[E3:%r[0-9]+]]}, [test_s_i32x4_param_0+8];\r
792 ; CHECK-DAG: ld.param.v2.u32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_s_i32x4_param_0];\r
793 ; CHECK: .param .align 8 .b8 param0[24];\r
794 ; CHECK: st.param.v2.b32 [param0+0], {[[E0]], [[E1]]};\r
795 ; CHECK: st.param.v2.b32 [param0+8], {[[E2]], [[E3]]};\r
796 ; CHECK: st.param.b64 [param0+16], [[E4]];\r
797 ; CHECK: .param .align 8 .b8 retval0[24];\r
798 ; CHECK: call.uni (retval0),\r
799 ; CHECK-NEXT: test_s_i32x4,\r
800 ; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0+0];\r
801 ; CHECK: ld.param.v2.b32 {[[RE2:%r[0-9]+]], [[RE3:%r[0-9]+]]}, [retval0+8];\r
802 ; CHECK: ld.param.b64 [[RE4:%rd[0-9]+]], [retval0+16];\r
803 ; CHECK-DAG: st.param.v2.b32 [func_retval0+0], {[[RE0]], [[RE1]]};\r
804 ; CHECK-DAG: st.param.v2.b32 [func_retval0+8], {[[RE2]], [[RE3]]};\r
805 ; CHECK-DAG: st.param.b64 [func_retval0+16], [[RE4]];\r
806 ; CHECK: ret;\r
807 \r
808 define %s_i32x4 @test_s_i32x4(%s_i32x4 %a) {\r
809 %r = tail call %s_i32x4 @test_s_i32x4(%s_i32x4 %a);\r
810 ret %s_i32x4 %r;\r
811 }\r
812 \r
813 ; CHECK:.visible .func (.param .align 8 .b8 func_retval0[32])\r
814 ; CHECK-LABEL: test_s_i1i32x4(\r
815 ; CHECK: .param .align 8 .b8 test_s_i1i32x4_param_0[32]\r
816 ; CHECK: ld.param.u64 [[E5:%rd[0-9]+]], [test_s_i1i32x4_param_0+24];\r
817 ; CHECK: ld.param.u32 [[E4:%r[0-9]+]], [test_s_i1i32x4_param_0+16];\r
818 ; CHECK: ld.param.u32 [[E3:%r[0-9]+]], [test_s_i1i32x4_param_0+12];\r
819 ; CHECK: ld.param.u8 [[E2:%rs[0-9]+]], [test_s_i1i32x4_param_0+8];\r
820 ; CHECK: ld.param.v2.u32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_s_i1i32x4_param_0];\r
821 ; CHECK: .param .align 8 .b8 param0[32];\r
822 ; CHECK: st.param.v2.b32 [param0+0], {[[E0]], [[E1]]};\r
823 ; CHECK: st.param.b8 [param0+8], [[E2]];\r
824 ; CHECK: st.param.b32 [param0+12], [[E3]];\r
825 ; CHECK: st.param.b32 [param0+16], [[E4]];\r
826 ; CHECK: st.param.b64 [param0+24], [[E5]];\r
827 ; CHECK: .param .align 8 .b8 retval0[32];\r
828 ; CHECK: call.uni (retval0),\r
829 ; CHECK: test_s_i1i32x4,\r
830 ; CHECK: (\r
831 ; CHECK: param0\r
832 ; CHECK: );\r
833 ; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0+0];\r
834 ; CHECK: ld.param.b8 [[RE2:%rs[0-9]+]], [retval0+8];\r
835 ; CHECK: ld.param.b32 [[RE3:%r[0-9]+]], [retval0+12];\r
836 ; CHECK: ld.param.b32 [[RE4:%r[0-9]+]], [retval0+16];\r
837 ; CHECK: ld.param.b64 [[RE5:%rd[0-9]+]], [retval0+24];\r
838 ; CHECK: st.param.v2.b32 [func_retval0+0], {[[RE0]], [[RE1]]};\r
839 ; CHECK: st.param.b8 [func_retval0+8], [[RE2]];\r
840 ; CHECK: st.param.b32 [func_retval0+12], [[RE3]];\r
841 ; CHECK: st.param.b32 [func_retval0+16], [[RE4]];\r
842 ; CHECK: st.param.b64 [func_retval0+24], [[RE5]];\r
843 ; CHECK: ret;\r
844 \r
845 define %s_i8i32x4 @test_s_i1i32x4(%s_i8i32x4 %a) {\r
846 %r = tail call %s_i8i32x4 @test_s_i1i32x4(%s_i8i32x4 %a);\r
847 ret %s_i8i32x4 %r;\r
848 }\r
849 \r
850 ; -- All loads/stores from parameters aligned by one must be done one\r
851 ; -- byte at a time.\r
852 ; CHECK:.visible .func (.param .align 1 .b8 func_retval0[25])\r
853 ; CHECK-LABEL: test_s_i1i32x4p(\r
854 ; CHECK-DAG: .param .align 1 .b8 test_s_i1i32x4p_param_0[25]\r
855 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+24];\r
856 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+23];\r
857 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+22];\r
858 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+21];\r
859 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+20];\r
860 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+19];\r
861 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+18];\r
862 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+17];\r
863 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+16];\r
864 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+15];\r
865 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+14];\r
866 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+13];\r
867 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+12];\r
868 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+11];\r
869 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+10];\r
870 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+9];\r
871 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+8];\r
872 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+7];\r
873 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+6];\r
874 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+5];\r
875 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+4];\r
876 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+3];\r
877 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+2];\r
878 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0+1];\r
879 ; CHECK-DAG: ld.param.u8 %r{{.*}}, [test_s_i1i32x4p_param_0];\r
880 ; --- TODO\r
881 ; --- Unaligned parameter store/ return value load is broken in both nvcc\r
882 ; --- and llvm and needs to be fixed.\r
883 ; CHECK: .param .align 1 .b8 param0[25];\r
884 ; CHECK-DAG: st.param.b32 [param0+0],\r
885 ; CHECK-DAG: st.param.b32 [param0+4],\r
886 ; CHECK-DAG: st.param.b8 [param0+8],\r
887 ; CHECK-DAG: st.param.b32 [param0+9],\r
888 ; CHECK-DAG: st.param.b32 [param0+13],\r
889 ; CHECK-DAG: st.param.b64 [param0+17],\r
890 ; CHECK: .param .align 1 .b8 retval0[25];\r
891 ; CHECK: call.uni (retval0),\r
892 ; CHECK-NEXT: test_s_i1i32x4p,\r
893 ; CHECK-DAG: ld.param.b32 %r41, [retval0+0];\r
894 ; CHECK-DAG: ld.param.b32 %r42, [retval0+4];\r
895 ; CHECK-DAG: ld.param.b8 %rs2, [retval0+8];\r
896 ; CHECK-DAG: ld.param.b32 %r43, [retval0+9];\r
897 ; CHECK-DAG: ld.param.b32 %r44, [retval0+13];\r
898 ; CHECK-DAG: ld.param.b64 %rd23, [retval0+17];\r
899 ; CHECK-DAG: st.param.b32 [func_retval0+0],\r
900 ; CHECK-DAG: st.param.b32 [func_retval0+4],\r
901 ; CHECK-DAG: st.param.b8 [func_retval0+8],\r
902 ; CHECK-DAG: st.param.b32 [func_retval0+9],\r
903 ; CHECK-DAG: st.param.b32 [func_retval0+13],\r
904 ; CHECK-DAG: st.param.b64 [func_retval0+17],\r
905 \r
906 define %s_i8i32x4p @test_s_i1i32x4p(%s_i8i32x4p %a) {\r
907 %r = tail call %s_i8i32x4p @test_s_i1i32x4p(%s_i8i32x4p %a);\r
908 ret %s_i8i32x4p %r;\r
909 }\r
910 \r
911 ; Check that we can vectorize loads that span multiple aggregate fields.\r
912 ; CHECK:.visible .func (.param .align 16 .b8 func_retval0[80])\r
913 ; CHECK-LABEL: test_s_crossfield(\r
914 ; CHECK: .param .align 16 .b8 test_s_crossfield_param_0[80]\r
915 ; CHECK: ld.param.u32 [[E15:%r[0-9]+]], [test_s_crossfield_param_0+64];\r
916 ; CHECK: ld.param.v4.u32 {[[E11:%r[0-9]+]], [[E12:%r[0-9]+]], [[E13:%r[0-9]+]], [[E14:%r[0-9]+]]}, [test_s_crossfield_param_0+48];\r
917 ; CHECK: ld.param.v4.u32 {[[E7:%r[0-9]+]], [[E8:%r[0-9]+]], [[E9:%r[0-9]+]], [[E10:%r[0-9]+]]}, [test_s_crossfield_param_0+32];\r
918 ; CHECK: ld.param.v4.u32 {[[E3:%r[0-9]+]], [[E4:%r[0-9]+]], [[E5:%r[0-9]+]], [[E6:%r[0-9]+]]}, [test_s_crossfield_param_0+16];\r
919 ; CHECK: ld.param.u32 [[E2:%r[0-9]+]], [test_s_crossfield_param_0+8];\r
920 ; CHECK: ld.param.v2.u32 {[[E0:%r[0-9]+]], [[E1:%r[0-9]+]]}, [test_s_crossfield_param_0];\r
921 ; CHECK: .param .align 16 .b8 param0[80];\r
922 ; CHECK: st.param.v2.b32 [param0+0], {[[E0]], [[E1]]};\r
923 ; CHECK: st.param.b32 [param0+8], [[E2]];\r
924 ; CHECK: st.param.v4.b32 [param0+16], {[[E3]], [[E4]], [[E5]], [[E6]]};\r
925 ; CHECK: st.param.v4.b32 [param0+32], {[[E7]], [[E8]], [[E9]], [[E10]]};\r
926 ; CHECK: st.param.v4.b32 [param0+48], {[[E11]], [[E12]], [[E13]], [[E14]]};\r
927 ; CHECK: st.param.b32 [param0+64], [[E15]];\r
928 ; CHECK: .param .align 16 .b8 retval0[80];\r
929 ; CHECK: call.uni (retval0),\r
930 ; CHECK: test_s_crossfield,\r
931 ; CHECK: ld.param.v2.b32 {[[RE0:%r[0-9]+]], [[RE1:%r[0-9]+]]}, [retval0+0];\r
932 ; CHECK: ld.param.b32 [[RE2:%r[0-9]+]], [retval0+8];\r
933 ; CHECK: ld.param.v4.b32 {[[RE3:%r[0-9]+]], [[RE4:%r[0-9]+]], [[RE5:%r[0-9]+]], [[RE6:%r[0-9]+]]}, [retval0+16];\r
934 ; CHECK: ld.param.v4.b32 {[[RE7:%r[0-9]+]], [[RE8:%r[0-9]+]], [[RE9:%r[0-9]+]], [[RE10:%r[0-9]+]]}, [retval0+32];\r
935 ; CHECK: ld.param.v4.b32 {[[RE11:%r[0-9]+]], [[RE12:%r[0-9]+]], [[RE13:%r[0-9]+]], [[RE14:%r[0-9]+]]}, [retval0+48];\r
936 ; CHECK: ld.param.b32 [[RE15:%r[0-9]+]], [retval0+64];\r
937 ; CHECK: st.param.v2.b32 [func_retval0+0], {[[RE0]], [[RE1]]};\r
938 ; CHECK: st.param.b32 [func_retval0+8], [[RE2]];\r
939 ; CHECK: st.param.v4.b32 [func_retval0+16], {[[RE3]], [[RE4]], [[RE5]], [[RE6]]};\r
940 ; CHECK: st.param.v4.b32 [func_retval0+32], {[[RE7]], [[RE8]], [[RE9]], [[RE10]]};\r
941 ; CHECK: st.param.v4.b32 [func_retval0+48], {[[RE11]], [[RE12]], [[RE13]], [[RE14]]};\r
942 ; CHECK: st.param.b32 [func_retval0+64], [[RE15]];\r
943 ; CHECK: ret;\r
944 \r
945 define %s_crossfield @test_s_crossfield(%s_crossfield %a) {\r
946 %r = tail call %s_crossfield @test_s_crossfield(%s_crossfield %a);\r
947 ret %s_crossfield %r;\r
948 }\r