1 // RUN: %clang_cc1 -triple arm64-apple-ios7 -target-abi darwinpcs -emit-llvm -o - %s | FileCheck %s
2 // RUN: %clang_cc1 -triple aarch64-linux-android -emit-llvm -o - %s | FileCheck -check-prefix=ANDROID %s
3
4 #include <stdarg.h>
5
6 typedef __attribute__(( ext_vector_type(2) )) char __char2;
7 typedef __attribute__(( ext_vector_type(3) )) char __char3;
8 typedef __attribute__(( ext_vector_type(4) )) char __char4;
9 typedef __attribute__(( ext_vector_type(5) )) char __char5;
10 typedef __attribute__(( ext_vector_type(9) )) char __char9;
11 typedef __attribute__(( ext_vector_type(19) )) char __char19;
12 typedef __attribute__(( ext_vector_type(3) )) short __short3;
13 typedef __attribute__(( ext_vector_type(5) )) short __short5;
14 typedef __attribute__(( ext_vector_type(3) )) int __int3;
15 typedef __attribute__(( ext_vector_type(5) )) int __int5;
16 typedef __attribute__(( ext_vector_type(3) )) double __double3;
17
18 // Passing legal vector types as varargs. Check that we've allocated the appropriate size
varargs_vec_2c(int fixed,...)19 double varargs_vec_2c(int fixed, ...) {
20 // ANDROID: varargs_vec_2c
21 // ANDROID: [[VAR:%.*]] = alloca <2 x i8>, align 2
22 // ANDROID: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
23 // ANDROID: bitcast i8* [[AP_CUR]] to <2 x i8>*
24 va_list ap;
25 double sum = fixed;
26 va_start(ap, fixed);
27 __char2 c3 = va_arg(ap, __char2);
28 sum = sum + c3.x + c3.y;
29 va_end(ap);
30 return sum;
31 }
32
test_2c(__char2 * in)33 double test_2c(__char2 *in) {
34 // ANDROID: call double (i32, ...) @varargs_vec_2c(i32 3, i16 {{%.*}})
35 return varargs_vec_2c(3, *in);
36 }
37
varargs_vec_3c(int fixed,...)38 double varargs_vec_3c(int fixed, ...) {
39 // CHECK: varargs_vec_3c
40 // CHECK: alloca <3 x i8>, align 4
41 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
42 // CHECK: bitcast i8* [[AP_CUR]] to <3 x i8>*
43 va_list ap;
44 double sum = fixed;
45 va_start(ap, fixed);
46 __char3 c3 = va_arg(ap, __char3);
47 sum = sum + c3.x + c3.y;
48 va_end(ap);
49 return sum;
50 }
51
test_3c(__char3 * in)52 double test_3c(__char3 *in) {
53 // CHECK: test_3c
54 // CHECK: call double (i32, ...) @varargs_vec_3c(i32 3, i32 {{%.*}})
55 return varargs_vec_3c(3, *in);
56 }
57
varargs_vec_4c(int fixed,...)58 double varargs_vec_4c(int fixed, ...) {
59 // CHECK: varargs_vec_4c
60 // CHECK: alloca <4 x i8>, align 4
61 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
62 // CHECK: bitcast i8* [[AP_CUR]] to <4 x i8>*
63 va_list ap;
64 double sum = fixed;
65 va_start(ap, fixed);
66 __char4 c4 = va_arg(ap, __char4);
67 sum = sum + c4.x + c4.y;
68 va_end(ap);
69 return sum;
70 }
71
test_4c(__char4 * in)72 double test_4c(__char4 *in) {
73 // CHECK: test_4c
74 // CHECK: call double (i32, ...) @varargs_vec_4c(i32 4, i32 {{%.*}})
75 return varargs_vec_4c(4, *in);
76 }
77
varargs_vec_5c(int fixed,...)78 double varargs_vec_5c(int fixed, ...) {
79 // CHECK: varargs_vec_5c
80 // CHECK: alloca <5 x i8>, align 8
81 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
82 // CHECK: bitcast i8* [[AP_CUR]] to <5 x i8>*
83 va_list ap;
84 double sum = fixed;
85 va_start(ap, fixed);
86 __char5 c5 = va_arg(ap, __char5);
87 sum = sum + c5.x + c5.y;
88 va_end(ap);
89 return sum;
90 }
91
test_5c(__char5 * in)92 double test_5c(__char5 *in) {
93 // CHECK: test_5c
94 // CHECK: call double (i32, ...) @varargs_vec_5c(i32 5, <2 x i32> {{%.*}})
95 return varargs_vec_5c(5, *in);
96 }
97
varargs_vec_9c(int fixed,...)98 double varargs_vec_9c(int fixed, ...) {
99 // CHECK: varargs_vec_9c
100 // CHECK: alloca <9 x i8>, align 16
101 // CHECK: [[ALIGN:%.*]] = and i64 {{%.*}}, -16
102 // CHECK: [[AP_ALIGN:%.*]] = inttoptr i64 [[ALIGN]] to i8*
103 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_ALIGN]], i64 16
104 // CHECK: bitcast i8* [[AP_ALIGN]] to <9 x i8>*
105 va_list ap;
106 double sum = fixed;
107 va_start(ap, fixed);
108 __char9 c9 = va_arg(ap, __char9);
109 sum = sum + c9.x + c9.y;
110 va_end(ap);
111 return sum;
112 }
113
test_9c(__char9 * in)114 double test_9c(__char9 *in) {
115 // CHECK: test_9c
116 // CHECK: call double (i32, ...) @varargs_vec_9c(i32 9, <4 x i32> {{%.*}})
117 return varargs_vec_9c(9, *in);
118 }
119
varargs_vec_19c(int fixed,...)120 double varargs_vec_19c(int fixed, ...) {
121 // CHECK: varargs_vec_19c
122 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
123 // CHECK: [[VAR:%.*]] = bitcast i8* [[AP_CUR]] to <19 x i8>**
124 // CHECK: [[VAR2:%.*]] = load <19 x i8>*, <19 x i8>** [[VAR]]
125 va_list ap;
126 double sum = fixed;
127 va_start(ap, fixed);
128 __char19 c19 = va_arg(ap, __char19);
129 sum = sum + c19.x + c19.y;
130 va_end(ap);
131 return sum;
132 }
133
test_19c(__char19 * in)134 double test_19c(__char19 *in) {
135 // CHECK: test_19c
136 // CHECK: call double (i32, ...) @varargs_vec_19c(i32 19, <19 x i8>* {{%.*}})
137 return varargs_vec_19c(19, *in);
138 }
139
varargs_vec_3s(int fixed,...)140 double varargs_vec_3s(int fixed, ...) {
141 // CHECK: varargs_vec_3s
142 // CHECK: alloca <3 x i16>, align 8
143 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
144 // CHECK: bitcast i8* [[AP_CUR]] to <3 x i16>*
145 va_list ap;
146 double sum = fixed;
147 va_start(ap, fixed);
148 __short3 c3 = va_arg(ap, __short3);
149 sum = sum + c3.x + c3.y;
150 va_end(ap);
151 return sum;
152 }
153
test_3s(__short3 * in)154 double test_3s(__short3 *in) {
155 // CHECK: test_3s
156 // CHECK: call double (i32, ...) @varargs_vec_3s(i32 3, <2 x i32> {{%.*}})
157 return varargs_vec_3s(3, *in);
158 }
159
varargs_vec_5s(int fixed,...)160 double varargs_vec_5s(int fixed, ...) {
161 // CHECK: varargs_vec_5s
162 // CHECK: alloca <5 x i16>, align 16
163 // CHECK: [[ALIGN:%.*]] = and i64 {{%.*}}, -16
164 // CHECK: [[AP_ALIGN:%.*]] = inttoptr i64 [[ALIGN]] to i8*
165 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_ALIGN]], i64 16
166 // CHECK: bitcast i8* [[AP_ALIGN]] to <5 x i16>*
167 va_list ap;
168 double sum = fixed;
169 va_start(ap, fixed);
170 __short5 c5 = va_arg(ap, __short5);
171 sum = sum + c5.x + c5.y;
172 va_end(ap);
173 return sum;
174 }
175
test_5s(__short5 * in)176 double test_5s(__short5 *in) {
177 // CHECK: test_5s
178 // CHECK: call double (i32, ...) @varargs_vec_5s(i32 5, <4 x i32> {{%.*}})
179 return varargs_vec_5s(5, *in);
180 }
181
varargs_vec_3i(int fixed,...)182 double varargs_vec_3i(int fixed, ...) {
183 // CHECK: varargs_vec_3i
184 // CHECK: alloca <3 x i32>, align 16
185 // CHECK: [[ALIGN:%.*]] = and i64 {{%.*}}, -16
186 // CHECK: [[AP_ALIGN:%.*]] = inttoptr i64 [[ALIGN]] to i8*
187 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_ALIGN]], i64 16
188 // CHECK: bitcast i8* [[AP_ALIGN]] to <3 x i32>*
189 va_list ap;
190 double sum = fixed;
191 va_start(ap, fixed);
192 __int3 c3 = va_arg(ap, __int3);
193 sum = sum + c3.x + c3.y;
194 va_end(ap);
195 return sum;
196 }
197
test_3i(__int3 * in)198 double test_3i(__int3 *in) {
199 // CHECK: test_3i
200 // CHECK: call double (i32, ...) @varargs_vec_3i(i32 3, <4 x i32> {{%.*}})
201 return varargs_vec_3i(3, *in);
202 }
203
varargs_vec_5i(int fixed,...)204 double varargs_vec_5i(int fixed, ...) {
205 // CHECK: varargs_vec_5i
206 // CHECK: alloca <5 x i32>, align 16
207 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
208 // CHECK: [[VAR:%.*]] = bitcast i8* [[AP_CUR]] to <5 x i32>**
209 // CHECK: [[VAR2:%.*]] = load <5 x i32>*, <5 x i32>** [[VAR]]
210 va_list ap;
211 double sum = fixed;
212 va_start(ap, fixed);
213 __int5 c5 = va_arg(ap, __int5);
214 sum = sum + c5.x + c5.y;
215 va_end(ap);
216 return sum;
217 }
218
test_5i(__int5 * in)219 double test_5i(__int5 *in) {
220 // CHECK: test_5i
221 // CHECK: call double (i32, ...) @varargs_vec_5i(i32 5, <5 x i32>* {{%.*}})
222 return varargs_vec_5i(5, *in);
223 }
224
varargs_vec_3d(int fixed,...)225 double varargs_vec_3d(int fixed, ...) {
226 // CHECK: varargs_vec_3d
227 // CHECK: alloca <3 x double>, align 16
228 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
229 // CHECK: [[VAR:%.*]] = bitcast i8* [[AP_CUR]] to <3 x double>**
230 // CHECK: [[VAR2:%.*]] = load <3 x double>*, <3 x double>** [[VAR]]
231 va_list ap;
232 double sum = fixed;
233 va_start(ap, fixed);
234 __double3 c3 = va_arg(ap, __double3);
235 sum = sum + c3.x + c3.y;
236 va_end(ap);
237 return sum;
238 }
239
test_3d(__double3 * in)240 double test_3d(__double3 *in) {
241 // CHECK: test_3d
242 // CHECK: call double (i32, ...) @varargs_vec_3d(i32 3, <3 x double>* {{%.*}})
243 return varargs_vec_3d(3, *in);
244 }
245
varargs_vec(int fixed,...)246 double varargs_vec(int fixed, ...) {
247 // CHECK: varargs_vec
248 va_list ap;
249 double sum = fixed;
250 va_start(ap, fixed);
251 __char3 c3 = va_arg(ap, __char3);
252 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
253 // CHECK: bitcast i8* [[AP_CUR]] to <3 x i8>*
254 sum = sum + c3.x + c3.y;
255 __char5 c5 = va_arg(ap, __char5);
256 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
257 // CHECK: bitcast i8* [[AP_CUR]] to <5 x i8>*
258 sum = sum + c5.x + c5.y;
259 __char9 c9 = va_arg(ap, __char9);
260 // CHECK: [[ALIGN:%.*]] = and i64 {{%.*}}, -16
261 // CHECK: [[AP_ALIGN:%.*]] = inttoptr i64 [[ALIGN]] to i8*
262 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_ALIGN]], i64 16
263 // CHECK: bitcast i8* [[AP_ALIGN]] to <9 x i8>*
264 sum = sum + c9.x + c9.y;
265 __char19 c19 = va_arg(ap, __char19);
266 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
267 // CHECK: [[VAR:%.*]] = bitcast i8* [[AP_CUR]] to <19 x i8>**
268 // CHECK: [[VAR2:%.*]] = load <19 x i8>*, <19 x i8>** [[VAR]]
269 sum = sum + c19.x + c19.y;
270 __short3 s3 = va_arg(ap, __short3);
271 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
272 // CHECK: bitcast i8* [[AP_CUR]] to <3 x i16>*
273 sum = sum + s3.x + s3.y;
274 __short5 s5 = va_arg(ap, __short5);
275 // CHECK: [[ALIGN:%.*]] = and i64 {{%.*}}, -16
276 // CHECK: [[AP_ALIGN:%.*]] = inttoptr i64 [[ALIGN]] to i8*
277 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_ALIGN]], i64 16
278 // CHECK: bitcast i8* [[AP_ALIGN]] to <5 x i16>*
279 sum = sum + s5.x + s5.y;
280 __int3 i3 = va_arg(ap, __int3);
281 // CHECK: [[ALIGN:%.*]] = and i64 {{%.*}}, -16
282 // CHECK: [[AP_ALIGN:%.*]] = inttoptr i64 [[ALIGN]] to i8*
283 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_ALIGN]], i64 16
284 // CHECK: bitcast i8* [[AP_ALIGN]] to <3 x i32>*
285 sum = sum + i3.x + i3.y;
286 __int5 i5 = va_arg(ap, __int5);
287 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
288 // CHECK: [[VAR:%.*]] = bitcast i8* [[AP_CUR]] to <5 x i32>**
289 // CHECK: [[VAR2:%.*]] = load <5 x i32>*, <5 x i32>** [[VAR]]
290 sum = sum + i5.x + i5.y;
291 __double3 d3 = va_arg(ap, __double3);
292 // CHECK: [[AP_NEXT:%.*]] = getelementptr inbounds i8, i8* [[AP_CUR:%.*]], i64 8
293 // CHECK: [[VAR:%.*]] = bitcast i8* [[AP_CUR]] to <3 x double>**
294 // CHECK: [[VAR2:%.*]] = load <3 x double>*, <3 x double>** [[VAR]]
295 sum = sum + d3.x + d3.y;
296 va_end(ap);
297 return sum;
298 }
299
test(__char3 * c3,__char5 * c5,__char9 * c9,__char19 * c19,__short3 * s3,__short5 * s5,__int3 * i3,__int5 * i5,__double3 * d3)300 double test(__char3 *c3, __char5 *c5, __char9 *c9, __char19 *c19,
301 __short3 *s3, __short5 *s5, __int3 *i3, __int5 *i5,
302 __double3 *d3) {
303 double ret = varargs_vec(3, *c3, *c5, *c9, *c19, *s3, *s5, *i3, *i5, *d3);
304 // CHECK: call double (i32, ...) @varargs_vec(i32 3, i32 {{%.*}}, <2 x i32> {{%.*}}, <4 x i32> {{%.*}}, <19 x i8>* {{%.*}}, <2 x i32> {{%.*}}, <4 x i32> {{%.*}}, <4 x i32> {{%.*}}, <5 x i32>* {{%.*}}, <3 x double>* {{%.*}})
305 return ret;
306 }
307
args_vec_3c(int fixed,__char3 c3)308 __attribute__((noinline)) double args_vec_3c(int fixed, __char3 c3) {
309 // CHECK: args_vec_3c
310 // CHECK: [[C3:%.*]] = alloca <3 x i8>, align 4
311 // CHECK: [[TMP:%.*]] = bitcast <3 x i8>* [[C3]] to i32*
312 // CHECK: store i32 {{%.*}}, i32* [[TMP]]
313 double sum = fixed;
314 sum = sum + c3.x + c3.y;
315 return sum;
316 }
317
fixed_3c(__char3 * in)318 double fixed_3c(__char3 *in) {
319 // CHECK: fixed_3c
320 // CHECK: call double @args_vec_3c(i32 3, i32 {{%.*}})
321 return args_vec_3c(3, *in);
322 }
323
args_vec_5c(int fixed,__char5 c5)324 __attribute__((noinline)) double args_vec_5c(int fixed, __char5 c5) {
325 // CHECK: args_vec_5c
326 // CHECK: [[C5:%.*]] = alloca <5 x i8>, align 8
327 // CHECK: [[TMP:%.*]] = bitcast <5 x i8>* [[C5]] to <2 x i32>*
328 // CHECK: store <2 x i32> {{%.*}}, <2 x i32>* [[TMP]], align 8
329 double sum = fixed;
330 sum = sum + c5.x + c5.y;
331 return sum;
332 }
333
fixed_5c(__char5 * in)334 double fixed_5c(__char5 *in) {
335 // CHECK: fixed_5c
336 // CHECK: call double @args_vec_5c(i32 5, <2 x i32> {{%.*}})
337 return args_vec_5c(5, *in);
338 }
339
args_vec_9c(int fixed,__char9 c9)340 __attribute__((noinline)) double args_vec_9c(int fixed, __char9 c9) {
341 // CHECK: args_vec_9c
342 // CHECK: [[C9:%.*]] = alloca <9 x i8>, align 16
343 // CHECK: [[TMP:%.*]] = bitcast <9 x i8>* [[C9]] to <4 x i32>*
344 // CHECK: store <4 x i32> {{%.*}}, <4 x i32>* [[TMP]], align 16
345 double sum = fixed;
346 sum = sum + c9.x + c9.y;
347 return sum;
348 }
349
fixed_9c(__char9 * in)350 double fixed_9c(__char9 *in) {
351 // CHECK: fixed_9c
352 // CHECK: call double @args_vec_9c(i32 9, <4 x i32> {{%.*}})
353 return args_vec_9c(9, *in);
354 }
355
args_vec_19c(int fixed,__char19 c19)356 __attribute__((noinline)) double args_vec_19c(int fixed, __char19 c19) {
357 // CHECK: args_vec_19c
358 // CHECK: [[C19:%.*]] = load <19 x i8>, <19 x i8>* {{.*}}, align 16
359 double sum = fixed;
360 sum = sum + c19.x + c19.y;
361 return sum;
362 }
363
fixed_19c(__char19 * in)364 double fixed_19c(__char19 *in) {
365 // CHECK: fixed_19c
366 // CHECK: call double @args_vec_19c(i32 19, <19 x i8>* {{%.*}})
367 return args_vec_19c(19, *in);
368 }
369
args_vec_3s(int fixed,__short3 c3)370 __attribute__((noinline)) double args_vec_3s(int fixed, __short3 c3) {
371 // CHECK: args_vec_3s
372 // CHECK: [[C3:%.*]] = alloca <3 x i16>, align 8
373 // CHECK: [[TMP:%.*]] = bitcast <3 x i16>* [[C3]] to <2 x i32>*
374 // CHECK: store <2 x i32> {{%.*}}, <2 x i32>* [[TMP]], align 8
375 double sum = fixed;
376 sum = sum + c3.x + c3.y;
377 return sum;
378 }
379
fixed_3s(__short3 * in)380 double fixed_3s(__short3 *in) {
381 // CHECK: fixed_3s
382 // CHECK: call double @args_vec_3s(i32 3, <2 x i32> {{%.*}})
383 return args_vec_3s(3, *in);
384 }
385
args_vec_5s(int fixed,__short5 c5)386 __attribute__((noinline)) double args_vec_5s(int fixed, __short5 c5) {
387 // CHECK: args_vec_5s
388 // CHECK: [[C5:%.*]] = alloca <5 x i16>, align 16
389 // CHECK: [[TMP:%.*]] = bitcast <5 x i16>* [[C5]] to <4 x i32>*
390 // CHECK: store <4 x i32> {{%.*}}, <4 x i32>* [[TMP]], align 16
391 double sum = fixed;
392 sum = sum + c5.x + c5.y;
393 return sum;
394 }
395
fixed_5s(__short5 * in)396 double fixed_5s(__short5 *in) {
397 // CHECK: fixed_5s
398 // CHECK: call double @args_vec_5s(i32 5, <4 x i32> {{%.*}})
399 return args_vec_5s(5, *in);
400 }
401
args_vec_3i(int fixed,__int3 c3)402 __attribute__((noinline)) double args_vec_3i(int fixed, __int3 c3) {
403 // CHECK: args_vec_3i
404 // CHECK: [[C3:%.*]] = alloca <3 x i32>, align 16
405 // CHECK: [[TMP:%.*]] = bitcast <3 x i32>* [[C3]] to <4 x i32>*
406 // CHECK: store <4 x i32> {{%.*}}, <4 x i32>* [[TMP]], align 16
407 double sum = fixed;
408 sum = sum + c3.x + c3.y;
409 return sum;
410 }
411
fixed_3i(__int3 * in)412 double fixed_3i(__int3 *in) {
413 // CHECK: fixed_3i
414 // CHECK: call double @args_vec_3i(i32 3, <4 x i32> {{%.*}})
415 return args_vec_3i(3, *in);
416 }
417
args_vec_5i(int fixed,__int5 c5)418 __attribute__((noinline)) double args_vec_5i(int fixed, __int5 c5) {
419 // CHECK: args_vec_5i
420 // CHECK: [[C5:%.*]] = load <5 x i32>, <5 x i32>* {{%.*}}, align 16
421 double sum = fixed;
422 sum = sum + c5.x + c5.y;
423 return sum;
424 }
425
fixed_5i(__int5 * in)426 double fixed_5i(__int5 *in) {
427 // CHECK: fixed_5i
428 // CHECK: call double @args_vec_5i(i32 5, <5 x i32>* {{%.*}})
429 return args_vec_5i(5, *in);
430 }
431
args_vec_3d(int fixed,__double3 c3)432 __attribute__((noinline)) double args_vec_3d(int fixed, __double3 c3) {
433 // CHECK: args_vec_3d
434 // CHECK: [[CAST:%.*]] = bitcast <3 x double>* {{%.*}} to <4 x double>*
435 // CHECK: [[LOAD:%.*]] = load <4 x double>, <4 x double>* [[CAST]]
436 // CHECK: shufflevector <4 x double> [[LOAD]], <4 x double> undef, <3 x i32> <i32 0, i32 1, i32 2>
437 double sum = fixed;
438 sum = sum + c3.x + c3.y;
439 return sum;
440 }
441
fixed_3d(__double3 * in)442 double fixed_3d(__double3 *in) {
443 // CHECK: fixed_3d
444 // CHECK: call double @args_vec_3d(i32 3, <3 x double>* {{%.*}})
445 return args_vec_3d(3, *in);
446 }
447