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