1 // RUN: %clang_cc1 -no-opaque-pointers -no-enable-noundef-analysis -triple x86_64-apple-darwin10 -target-cpu core2 -emit-llvm -o - %s | FileCheck %s
2 // RUN: %clang_cc1 -no-opaque-pointers -no-enable-noundef-analysis -triple x86_64-apple-darwin10 -target-cpu core2 -emit-llvm -o - %s | FileCheck %s --check-prefix=X86-64
3 // RUN: %clang_cc1 -no-opaque-pointers -no-enable-noundef-analysis -triple arm64-apple-ios9 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s
4 // RUN: %clang_cc1 -no-opaque-pointers -no-enable-noundef-analysis -triple arm64-apple-ios9 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s --check-prefix=ARM64
5 
6 // REQUIRES: aarch64-registered-target,x86-registered-target
7 
8 #define SWIFTCALL __attribute__((swiftcall))
9 #define SWIFTASYNCCALL __attribute__((swiftasynccall))
10 #define OUT __attribute__((swift_indirect_result))
11 #define ERROR __attribute__((swift_error_result))
12 #define CONTEXT __attribute__((swift_context))
13 #define ASYNC_CONTEXT __attribute__((swift_async_context))
14 
15 // CHECK-DAG: %struct.atomic_padded = type { { %struct.packed, [7 x i8] } }
16 // CHECK-DAG: %struct.packed = type <{ i64, i8 }>
17 //
18 // CHECK: [[STRUCT2_RESULT:@.*]] = private {{.*}} constant [[STRUCT2_TYPE:%.*]] { i32 0, i8 0, i8 undef, i8 0, i32 0, i32 0 }
19 
20 /*****************************************************************************/
21 /****************************** PARAMETER ABIS *******************************/
22 /*****************************************************************************/
23 
indirect_result_1(OUT int * arg0,OUT float * arg1)24 SWIFTCALL void indirect_result_1(OUT int *arg0, OUT float *arg1) {}
25 // CHECK-LABEL: define {{.*}} void @indirect_result_1(i32* noalias sret(i32*) align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}})
26 
27 // TODO: maybe this shouldn't suppress sret.
indirect_result_2(OUT int * arg0,OUT float * arg1)28 SWIFTCALL int indirect_result_2(OUT int *arg0, OUT float *arg1) {  __builtin_unreachable(); }
29 // CHECK-LABEL: define {{.*}} i32 @indirect_result_2(i32* noalias align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}})
30 
31 typedef struct { char array[1024]; } struct_reallybig;
indirect_result_3(OUT int * arg0,OUT float * arg1)32 SWIFTCALL struct_reallybig indirect_result_3(OUT int *arg0, OUT float *arg1) { __builtin_unreachable(); }
33 // CHECK-LABEL: define {{.*}} void @indirect_result_3({{.*}}* noalias sret(%struct.struct_reallybig) {{.*}}, i32* noalias align 4 dereferenceable(4){{.*}}, float* noalias align 4 dereferenceable(4){{.*}})
34 
context_1(CONTEXT void * self)35 SWIFTCALL void context_1(CONTEXT void *self) {}
36 // CHECK-LABEL: define {{.*}} void @context_1(i8* swiftself
37 
async_context_1(ASYNC_CONTEXT void * ctx)38 SWIFTASYNCCALL void async_context_1(ASYNC_CONTEXT void *ctx) {}
39 // CHECK-LABEL: define {{.*}} void @async_context_1(i8* swiftasync
40 
context_2(void * arg0,CONTEXT void * self)41 SWIFTCALL void context_2(void *arg0, CONTEXT void *self) {}
42 // CHECK-LABEL: define {{.*}} void @context_2(i8*{{.*}}, i8* swiftself
43 
async_context_2(void * arg0,ASYNC_CONTEXT void * ctx)44 SWIFTASYNCCALL void async_context_2(void *arg0, ASYNC_CONTEXT void *ctx) {}
45 // CHECK-LABEL: define {{.*}} void @async_context_2(i8*{{.*}}, i8* swiftasync
46 
context_error_1(CONTEXT int * self,ERROR float ** error)47 SWIFTCALL void context_error_1(CONTEXT int *self, ERROR float **error) {}
48 // CHECK-LABEL: define {{.*}} void @context_error_1(i32* swiftself{{.*}}, float** swifterror %0)
49 // CHECK:       [[TEMP:%.*]] = alloca float*, align 8
50 // CHECK:       [[T0:%.*]] = load float*, float** [[ERRORARG:%.*]], align 8
51 // CHECK:       store float* [[T0]], float** [[TEMP]], align 8
52 // CHECK:       [[T0:%.*]] = load float*, float** [[TEMP]], align 8
53 // CHECK:       store float* [[T0]], float** [[ERRORARG]], align 8
test_context_error_1()54 void test_context_error_1() {
55   int x;
56   float *error;
57   context_error_1(&x, &error);
58 }
59 // CHECK-LABEL: define{{.*}} void @test_context_error_1()
60 // CHECK:       [[X:%.*]] = alloca i32, align 4
61 // CHECK:       [[ERROR:%.*]] = alloca float*, align 8
62 // CHECK:       [[TEMP:%.*]] = alloca swifterror float*, align 8
63 // CHECK:       [[T0:%.*]] = load float*, float** [[ERROR]], align 8
64 // CHECK:       store float* [[T0]], float** [[TEMP]], align 8
65 // CHECK:       call [[SWIFTCC:swiftcc]] void @context_error_1(i32* swiftself [[X]], float** swifterror [[TEMP]])
66 // CHECK:       [[T0:%.*]] = load float*, float** [[TEMP]], align 8
67 // CHECK:       store float* [[T0]], float** [[ERROR]], align 8
68 
context_error_2(short s,CONTEXT int * self,ERROR float ** error)69 SWIFTCALL void context_error_2(short s, CONTEXT int *self, ERROR float **error) {}
70 // CHECK-LABEL: define {{.*}} void @context_error_2(i16{{.*}}, i32* swiftself{{.*}}, float** swifterror %0)
71 
72 /*****************************************************************************/
73 /********************************** LOWERING *********************************/
74 /*****************************************************************************/
75 
76 typedef float float3 __attribute__((ext_vector_type(3)));
77 typedef float float4 __attribute__((ext_vector_type(4)));
78 typedef float float8 __attribute__((ext_vector_type(8)));
79 typedef double double2 __attribute__((ext_vector_type(2)));
80 typedef double double4 __attribute__((ext_vector_type(4)));
81 typedef int int3 __attribute__((ext_vector_type(3)));
82 typedef int int4 __attribute__((ext_vector_type(4)));
83 typedef int int5 __attribute__((ext_vector_type(5)));
84 typedef int int8 __attribute__((ext_vector_type(8)));
85 typedef char char16 __attribute__((ext_vector_type(16)));
86 typedef short short8 __attribute__((ext_vector_type(8)));
87 typedef long long long2 __attribute__((ext_vector_type(2)));
88 
89 #define TEST(TYPE)                       \
90   SWIFTCALL TYPE return_##TYPE(void) {   \
91     TYPE result = {};                    \
92     return result;                       \
93   }                                      \
94   SWIFTCALL void take_##TYPE(TYPE v) {   \
95   }                                      \
96   void test_##TYPE() {                   \
97     take_##TYPE(return_##TYPE());        \
98   }
99 
100 /*****************************************************************************/
101 /*********************************** STRUCTS *********************************/
102 /*****************************************************************************/
103 
104 typedef struct {
105 } struct_empty;
106 TEST(struct_empty);
107 // CHECK-LABEL: define {{.*}} @return_struct_empty()
108 // CHECK:   ret void
109 // CHECK-LABEL: define {{.*}} @take_struct_empty()
110 // CHECK:   ret void
111 
112 typedef struct {
113   int x;
114   char c0;
115   char c1;
116   int f0;
117   int f1;
118 } struct_1;
119 TEST(struct_1);
120 // CHECK-LABEL: define{{.*}} swiftcc { i64, i64 } @return_struct_1() {{.*}}{
121 // CHECK:   [[RET:%.*]] = alloca [[STRUCT1:%.*]], align 4
122 // CHECK:   call void @llvm.memset
123 // CHECK:   [[CAST:%.*]] = bitcast [[STRUCT1]]* %retval to { i64, i64 }*
124 // CHECK:   [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0
125 // CHECK:   [[T0:%.*]] = load i64, i64* [[GEP0]], align 4
126 // CHECK:   [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1
127 // CHECK:   [[T1:%.*]] = load i64, i64* [[GEP1]], align 4
128 // CHECK:   [[R0:%.*]] = insertvalue { i64, i64 } poison, i64 [[T0]], 0
129 // CHECK:   [[R1:%.*]] = insertvalue { i64, i64 } [[R0]], i64 [[T1]], 1
130 // CHECK:   ret { i64, i64 } [[R1]]
131 // CHECK: }
132 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_1(i64 %0, i64 %1) {{.*}}{
133 // CHECK:   [[V:%.*]] = alloca [[STRUCT1:%.*]], align 4
134 // CHECK:   [[CAST:%.*]] = bitcast [[STRUCT1]]* [[V]] to { i64, i64 }*
135 // CHECK:   [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0
136 // CHECK:   store i64 %0, i64* [[GEP0]], align 4
137 // CHECK:   [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1
138 // CHECK:   store i64 %1, i64* [[GEP1]], align 4
139 // CHECK:   ret void
140 // CHECK: }
141 // CHECK-LABEL: define{{.*}} void @test_struct_1() {{.*}}{
142 // CHECK:   [[AGG:%.*]] = alloca [[STRUCT1:%.*]], align 4
143 // CHECK:   [[RET:%.*]] = call swiftcc { i64, i64 } @return_struct_1()
144 // CHECK:   [[CAST:%.*]] = bitcast [[STRUCT1]]* [[AGG]] to { i64, i64 }*
145 // CHECK:   [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0
146 // CHECK:   [[E0:%.*]] = extractvalue { i64, i64 } [[RET]], 0
147 // CHECK:   store i64 [[E0]], i64* [[GEP0]], align 4
148 // CHECK:   [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1
149 // CHECK:   [[E1:%.*]] = extractvalue { i64, i64 } [[RET]], 1
150 // CHECK:   store i64 [[E1]], i64* [[GEP1]], align 4
151 // CHECK:   [[CAST2:%.*]] = bitcast [[STRUCT1]]* [[AGG]] to { i64, i64 }*
152 // CHECK:   [[GEP2:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST2]], i32 0, i32 0
153 // CHECK:   [[V0:%.*]] = load i64, i64* [[GEP2]], align 4
154 // CHECK:   [[GEP3:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST2]], i32 0, i32 1
155 // CHECK:   [[V1:%.*]] = load i64, i64* [[GEP3]], align 4
156 // CHECK:   call swiftcc void @take_struct_1(i64 [[V0]], i64 [[V1]])
157 // CHECK:   ret void
158 // CHECK: }
159 
160 typedef struct {
161   int x;
162   char c0;
163   __attribute__((aligned(2))) char c1;
164   int f0;
165   int f1;
166 } struct_2;
167 TEST(struct_2);
168 // CHECK-LABEL: define{{.*}} swiftcc { i64, i64 } @return_struct_2() {{.*}}{
169 // CHECK:   [[RET:%.*]] = alloca [[STRUCT2_TYPE]], align 4
170 // CHECK:   [[CASTVAR:%.*]] = bitcast {{.*}} [[RET]]
171 // CHECK:   call void @llvm.memcpy{{.*}}({{.*}}[[CASTVAR]], {{.*}}[[STRUCT2_RESULT]]
172 // CHECK:   [[CAST:%.*]] = bitcast [[STRUCT2_TYPE]]* [[RET]] to { i64, i64 }*
173 // CHECK:   [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0
174 // CHECK:   [[T0:%.*]] = load i64, i64* [[GEP0]], align 4
175 // CHECK:   [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1
176 // CHECK:   [[T1:%.*]] = load i64, i64* [[GEP1]], align 4
177 // CHECK:   [[R0:%.*]] = insertvalue { i64, i64 } poison, i64 [[T0]], 0
178 // CHECK:   [[R1:%.*]] = insertvalue { i64, i64 } [[R0]], i64 [[T1]], 1
179 // CHECK:   ret { i64, i64 } [[R1]]
180 // CHECK: }
181 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_2(i64 %0, i64 %1) {{.*}}{
182 // CHECK:   [[V:%.*]] = alloca [[STRUCT:%.*]], align 4
183 // CHECK:   [[CAST:%.*]] = bitcast [[STRUCT]]* [[V]] to { i64, i64 }*
184 // CHECK:   [[GEP0:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0
185 // CHECK:   store i64 %0, i64* [[GEP0]], align 4
186 // CHECK:   [[GEP1:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1
187 // CHECK:   store i64 %1, i64* [[GEP1]], align 4
188 // CHECK:   ret void
189 // CHECK: }
190 // CHECK-LABEL: define{{.*}} void @test_struct_2() {{.*}} {
191 // CHECK:   [[TMP:%.*]] = alloca [[STRUCT2_TYPE]], align 4
192 // CHECK:   [[CALL:%.*]] = call swiftcc { i64, i64 } @return_struct_2()
193 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[STRUCT2_TYPE]]* [[TMP]] to { i64, i64 }*
194 // CHECK:   [[GEP:%.*]] = getelementptr inbounds {{.*}} [[CAST_TMP]], i32 0, i32 0
195 // CHECK:   [[T0:%.*]] = extractvalue { i64, i64 } [[CALL]], 0
196 // CHECK:   store i64 [[T0]], i64* [[GEP]], align 4
197 // CHECK:   [[GEP:%.*]] = getelementptr inbounds {{.*}} [[CAST_TMP]], i32 0, i32 1
198 // CHECK:   [[T0:%.*]] = extractvalue { i64, i64 } [[CALL]], 1
199 // CHECK:   store i64 [[T0]], i64* [[GEP]], align 4
200 // CHECK:   [[CAST:%.*]] = bitcast [[STRUCT2_TYPE]]* [[TMP]] to { i64, i64 }*
201 // CHECK:   [[GEP:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 0
202 // CHECK:   [[R0:%.*]] = load i64, i64* [[GEP]], align 4
203 // CHECK:   [[GEP:%.*]] = getelementptr inbounds { i64, i64 }, { i64, i64 }* [[CAST]], i32 0, i32 1
204 // CHECK:   [[R1:%.*]] = load i64, i64* [[GEP]], align 4
205 // CHECK:   call swiftcc void @take_struct_2(i64 [[R0]], i64 [[R1]])
206 // CHECK:   ret void
207 // CHECK: }
208 
209 // There's no way to put a field randomly in the middle of an otherwise
210 // empty storage unit in C, so that case has to be tested in C++, which
211 // can use empty structs to introduce arbitrary padding.  (In C, they end up
212 // with size 0 and so don't affect layout.)
213 
214 // Misaligned data rule.
215 typedef struct {
216   char c0;
217   __attribute__((packed)) float f;
218 } struct_misaligned_1;
219 TEST(struct_misaligned_1)
220 // CHECK-LABEL: define{{.*}} swiftcc i64 @return_struct_misaligned_1()
221 // CHECK:  [[RET:%.*]] = alloca [[STRUCT:%.*]], align 1
222 // CHECK:  [[CAST:%.*]] = bitcast [[STRUCT]]* [[RET]] to i8*
223 // CHECK:  call void @llvm.memset{{.*}}(i8* align 1 [[CAST]], i8 0, i64 5
224 // CHECK:  [[CAST:%.*]] = bitcast [[STRUCT]]* [[RET]] to { i64 }*
225 // CHECK:  [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0
226 // CHECK:  [[R0:%.*]] = load i64, i64* [[GEP]], align 1
227 // CHECK:  ret i64 [[R0]]
228 // CHECK:}
229 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_misaligned_1(i64 %0) {{.*}}{
230 // CHECK:   [[V:%.*]] = alloca [[STRUCT:%.*]], align 1
231 // CHECK:   [[CAST:%.*]] = bitcast [[STRUCT]]* [[V]] to { i64 }*
232 // CHECK:   [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0
233 // CHECK:   store i64 %0, i64* [[GEP]], align 1
234 // CHECK:   ret void
235 // CHECK: }
236 // CHECK: define{{.*}} void @test_struct_misaligned_1() {{.*}}{
237 // CHECK:   [[AGG:%.*]] = alloca [[STRUCT:%.*]], align 1
238 // CHECK:   [[CALL:%.*]] = call swiftcc i64 @return_struct_misaligned_1()
239 // CHECK:   [[T0:%.*]] = bitcast [[STRUCT]]* [[AGG]] to { i64 }*
240 // CHECK:   [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0
241 // CHECK:   store i64 [[CALL]], i64* [[T1]], align 1
242 // CHECK:   [[T0:%.*]] = bitcast [[STRUCT]]* [[AGG]] to { i64 }*
243 // CHECK:   [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0
244 // CHECK:   [[P:%.*]] = load i64, i64* [[T1]], align 1
245 // CHECK:   call swiftcc void @take_struct_misaligned_1(i64 [[P]])
246 // CHECK:   ret void
247 // CHECK: }
248 
249 // Too many scalars.
250 typedef struct {
251   long long x[5];
252 } struct_big_1;
253 TEST(struct_big_1)
254 
255 // CHECK-LABEL: define {{.*}} void @return_struct_big_1({{.*}} noalias sret
256 
257 // Should not be byval.
258 // CHECK-LABEL: define {{.*}} void @take_struct_big_1({{.*}}*{{( %.*)?}})
259 
260 /*****************************************************************************/
261 /********************************* TYPE MERGING ******************************/
262 /*****************************************************************************/
263 
264 typedef union {
265   float f;
266   double d;
267 } union_het_fp;
268 TEST(union_het_fp)
269 // CHECK-LABEL: define{{.*}} swiftcc i64 @return_union_het_fp()
270 // CHECK:  [[RET:%.*]] = alloca [[UNION:%.*]], align 8
271 // CHECK:  [[CAST:%.*]] = bitcast [[UNION]]* [[RET]] to i8*
272 // CHECK:  call void @llvm.memcpy{{.*}}(i8* align 8 [[CAST]]
273 // CHECK:  [[CAST:%.*]] = bitcast [[UNION]]* [[RET]] to { i64 }*
274 // CHECK:  [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0
275 // CHECK:  [[R0:%.*]] = load i64, i64* [[GEP]], align 8
276 // CHECK:  ret i64 [[R0]]
277 // CHECK-LABEL: define{{.*}} swiftcc void @take_union_het_fp(i64 %0) {{.*}}{
278 // CHECK:   [[V:%.*]] = alloca [[UNION:%.*]], align 8
279 // CHECK:   [[CAST:%.*]] = bitcast [[UNION]]* [[V]] to { i64 }*
280 // CHECK:   [[GEP:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[CAST]], i32 0, i32 0
281 // CHECK:   store i64 %0, i64* [[GEP]], align 8
282 // CHECK:   ret void
283 // CHECK: }
284 // CHECK-LABEL: define{{.*}} void @test_union_het_fp() {{.*}}{
285 // CHECK:   [[AGG:%.*]] = alloca [[UNION:%.*]], align 8
286 // CHECK:   [[CALL:%.*]] = call swiftcc i64 @return_union_het_fp()
287 // CHECK:   [[T0:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64 }*
288 // CHECK:   [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0
289 // CHECK:   store i64 [[CALL]], i64* [[T1]], align 8
290 // CHECK:   [[T0:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64 }*
291 // CHECK:   [[T1:%.*]] = getelementptr inbounds { i64 }, { i64 }* [[T0]], i32 0, i32 0
292 // CHECK:   [[V0:%.*]] = load i64, i64* [[T1]], align 8
293 // CHECK:   call swiftcc void @take_union_het_fp(i64 [[V0]])
294 // CHECK:   ret void
295 // CHECK: }
296 
297 
298 typedef union {
299   float f1;
300   float f2;
301 } union_hom_fp;
302 TEST(union_hom_fp)
303 // CHECK-LABEL: define{{.*}} void @test_union_hom_fp()
304 // CHECK:   [[TMP:%.*]] = alloca [[REC:%.*]], align 4
305 // CHECK:   [[CALL:%.*]] = call [[SWIFTCC]] float @return_union_hom_fp()
306 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG:{ float }]]*
307 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
308 // CHECK:   store float [[CALL]], float* [[T0]], align 4
309 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP]] to [[AGG]]*
310 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
311 // CHECK:   [[FIRST:%.*]] = load float, float* [[T0]], align 4
312 // CHECK:   call [[SWIFTCC]] void @take_union_hom_fp(float [[FIRST]])
313 // CHECK:   ret void
314 
315 typedef union {
316   float f1;
317   float4 fv2;
318 } union_hom_fp_partial;
319 TEST(union_hom_fp_partial)
320 // CHECK: define{{.*}} void @test_union_hom_fp_partial()
321 // CHECK:   [[AGG:%.*]] = alloca [[UNION:%.*]], align 16
322 // CHECK:   [[CALL:%.*]] = call swiftcc { float, float, float, float } @return_union_hom_fp_partial()
323 // CHECK:   [[CAST:%.*]] = bitcast [[UNION]]* [[AGG]] to { float, float, float, float }*
324 // CHECK:   [[T0:%.*]] = getelementptr inbounds { float, float, float, float }, { float, float, float, float }* [[CAST]], i32 0, i32 0
325 // CHECK:   [[T1:%.*]] = extractvalue { float, float, float, float } [[CALL]], 0
326 // CHECK:   store float [[T1]], float* [[T0]], align 16
327 // CHECK:   [[T0:%.*]] = getelementptr inbounds { float, float, float, float }, { float, float, float, float }* [[CAST]], i32 0, i32 1
328 // CHECK:   [[T1:%.*]] = extractvalue { float, float, float, float } [[CALL]], 1
329 // CHECK:   store float [[T1]], float* [[T0]], align 4
330 // CHECK:   [[T0:%.*]] = getelementptr inbounds { float, float, float, float }, { float, float, float, float }* [[CAST]], i32 0, i32 2
331 // CHECK:   [[T1:%.*]] = extractvalue { float, float, float, float } [[CALL]], 2
332 // CHECK:   store float [[T1]], float* [[T0]], align 8
333 // CHECK:   [[T0:%.*]] = getelementptr inbounds { float, float, float, float }, { float, float, float, float }* [[CAST]], i32 0, i32 3
334 // CHECK:   [[T1:%.*]] = extractvalue { float, float, float, float } [[CALL]], 3
335 // CHECK:   store float [[T1]], float* [[T0]], align 4
336 // CHECK:   [[CAST:%.*]] = bitcast [[UNION]]* [[AGG]] to { float, float, float, float }*
337 // CHECK:   [[T0:%.*]] = getelementptr inbounds { float, float, float, float }, { float, float, float, float }* [[CAST]], i32 0, i32 0
338 // CHECK:   [[V0:%.*]] = load float, float* [[T0]], align 16
339 // CHECK:   [[T0:%.*]] = getelementptr inbounds { float, float, float, float }, { float, float, float, float }* [[CAST]], i32 0, i32 1
340 // CHECK:   [[V1:%.*]] = load float, float* [[T0]], align 4
341 // CHECK:   [[T0:%.*]] = getelementptr inbounds { float, float, float, float }, { float, float, float, float }* [[CAST]], i32 0, i32 2
342 // CHECK:   [[V2:%.*]] = load float, float* [[T0]], align 8
343 // CHECK:   [[T0:%.*]] = getelementptr inbounds { float, float, float, float }, { float, float, float, float }* [[CAST]], i32 0, i32 3
344 // CHECK:   [[V3:%.*]] = load float, float* [[T0]], align 4
345 // CHECK:   call swiftcc void @take_union_hom_fp_partial(float [[V0]], float [[V1]], float [[V2]], float [[V3]])
346 // CHECK:   ret void
347 // CHECK: }
348 
349 typedef union {
350   struct { int x, y; } f1;
351   float4 fv2;
352 } union_het_fpv_partial;
353 TEST(union_het_fpv_partial)
354 // CHECK-LABEL: define{{.*}} void @test_union_het_fpv_partial()
355 // CHECK:   [[AGG:%.*]] = alloca [[UNION:%.*]], align 16
356 // CHECK:   [[CALL:%.*]] = call swiftcc { i64, float, float } @return_union_het_fpv_partial()
357 // CHECK:   [[CAST:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64, float, float }*
358 // CHECK:   [[T0:%.*]] = getelementptr inbounds { i64, float, float }, { i64, float, float }* [[CAST]], i32 0, i32 0
359 // CHECK:   [[T1:%.*]] = extractvalue { i64, float, float } [[CALL]], 0
360 // CHECK:   store i64 [[T1]], i64* [[T0]], align 16
361 // CHECK:   [[T0:%.*]] = getelementptr inbounds { i64, float, float }, { i64, float, float }* [[CAST]], i32 0, i32 1
362 // CHECK:   [[T1:%.*]] = extractvalue { i64, float, float } [[CALL]], 1
363 // CHECK:   store float [[T1]], float* [[T0]], align 8
364 // CHECK:   [[T0:%.*]] = getelementptr inbounds { i64, float, float }, { i64, float, float }* [[CAST]], i32 0, i32 2
365 // CHECK:   [[T1:%.*]] = extractvalue { i64, float, float } [[CALL]], 2
366 // CHECK:   store float [[T1]], float* [[T0]], align 4
367 // CHECK:   [[CAST:%.*]] = bitcast [[UNION]]* [[AGG]] to { i64, float, float }*
368 // CHECK:   [[T0:%.*]] = getelementptr inbounds { i64, float, float }, { i64, float, float }* [[CAST]], i32 0, i32 0
369 // CHECK:   [[V0:%.*]] = load i64, i64* [[T0]], align 16
370 // CHECK:   [[T0:%.*]] = getelementptr inbounds { i64, float, float }, { i64, float, float }* [[CAST]], i32 0, i32 1
371 // CHECK:   [[V1:%.*]] = load float, float* [[T0]], align 8
372 // CHECK:   [[T0:%.*]] = getelementptr inbounds { i64, float, float }, { i64, float, float }* [[CAST]], i32 0, i32 2
373 // CHECK:   [[V2:%.*]] = load float, float* [[T0]], align 4
374 // CHECK:   call swiftcc void @take_union_het_fpv_partial(i64 [[V0]], float [[V1]], float [[V2]])
375 // CHECK:   ret void
376 // CHECK: }
377 
378 /*****************************************************************************/
379 /****************************** VECTOR LEGALIZATION **************************/
380 /*****************************************************************************/
381 
382 TEST(int4)
383 // CHECK-LABEL: define {{.*}} <4 x i32> @return_int4()
384 // CHECK-LABEL: define {{.*}} @take_int4(<4 x i32>
385 
386 TEST(int8)
387 // CHECK-LABEL: define {{.*}} @return_int8()
388 // CHECK:   [[RET:%.*]] = alloca [[REC:<8 x i32>]], align 16
389 // CHECK:   [[VAR:%.*]] = alloca [[REC]], align
390 // CHECK:   store
391 // CHECK:   load
392 // CHECK:   store
393 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ <4 x i32>, <4 x i32> }]]*
394 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
395 // CHECK:   [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align
396 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
397 // CHECK:   [[SECOND:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align
398 // CHECK:   [[T0:%.*]] = insertvalue [[UAGG:{ <4 x i32>, <4 x i32> }]] poison, <4 x i32> [[FIRST]], 0
399 // CHECK:   [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], <4 x i32> [[SECOND]], 1
400 // CHECK:   ret [[UAGG]] [[T1]]
401 // CHECK-LABEL: define {{.*}} @take_int8(<4 x i32> %0, <4 x i32> %1)
402 // CHECK:   [[V:%.*]] = alloca [[REC]], align
403 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*
404 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
405 // CHECK:   store <4 x i32> %0, <4 x i32>* [[T0]], align
406 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
407 // CHECK:   store <4 x i32> %1, <4 x i32>* [[T0]], align
408 // CHECK:   ret void
409 // CHECK-LABEL: define{{.*}} void @test_int8()
410 // CHECK:   [[TMP1:%.*]] = alloca [[REC]], align
411 // CHECK:   [[TMP2:%.*]] = alloca [[REC]], align
412 // CHECK:   [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_int8()
413 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP1]] to [[AGG]]*
414 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
415 // CHECK:   [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0
416 // CHECK:   store <4 x i32> [[T1]], <4 x i32>* [[T0]], align
417 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
418 // CHECK:   [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1
419 // CHECK:   store <4 x i32> [[T1]], <4 x i32>* [[T0]], align
420 // CHECK:   [[V:%.*]] = load [[REC]], [[REC]]* [[TMP1]], align
421 // CHECK:   store [[REC]] [[V]], [[REC]]* [[TMP2]], align
422 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP2]] to [[AGG]]*
423 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
424 // CHECK:   [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align
425 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
426 // CHECK:   [[SECOND:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align
427 // CHECK:   call [[SWIFTCC]] void @take_int8(<4 x i32> [[FIRST]], <4 x i32> [[SECOND]])
428 // CHECK:   ret void
429 
430 TEST(int5)
431 // CHECK-LABEL: define {{.*}} @return_int5()
432 // CHECK:   [[RET:%.*]] = alloca [[REC:<5 x i32>]], align 16
433 // CHECK:   [[VAR:%.*]] = alloca [[REC]], align
434 // CHECK:   store
435 // CHECK:   load
436 // CHECK:   store
437 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[RET]] to [[AGG:{ <4 x i32>, i32 }]]*
438 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
439 // CHECK:   [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align
440 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
441 // CHECK:   [[SECOND:%.*]] = load i32, i32* [[T0]], align
442 // CHECK:   [[T0:%.*]] = insertvalue [[UAGG:{ <4 x i32>, i32 }]] poison, <4 x i32> [[FIRST]], 0
443 // CHECK:   [[T1:%.*]] = insertvalue [[UAGG]] [[T0]], i32 [[SECOND]], 1
444 // CHECK:   ret [[UAGG]] [[T1]]
445 // CHECK-LABEL: define {{.*}} @take_int5(<4 x i32> %0, i32 %1)
446 // CHECK:   [[V:%.*]] = alloca [[REC]], align
447 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[V]] to [[AGG]]*
448 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
449 // CHECK:   store <4 x i32> %0, <4 x i32>* [[T0]], align
450 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
451 // CHECK:   store i32 %1, i32* [[T0]], align
452 // CHECK:   ret void
453 // CHECK-LABEL: define{{.*}} void @test_int5()
454 // CHECK:   [[TMP1:%.*]] = alloca [[REC]], align
455 // CHECK:   [[TMP2:%.*]] = alloca [[REC]], align
456 // CHECK:   [[CALL:%.*]] = call [[SWIFTCC]] [[UAGG]] @return_int5()
457 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP1]] to [[AGG]]*
458 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
459 // CHECK:   [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 0
460 // CHECK:   store <4 x i32> [[T1]], <4 x i32>* [[T0]], align
461 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
462 // CHECK:   [[T1:%.*]] = extractvalue [[UAGG]] [[CALL]], 1
463 // CHECK:   store i32 [[T1]], i32* [[T0]], align
464 // CHECK:   [[V:%.*]] = load [[REC]], [[REC]]* [[TMP1]], align
465 // CHECK:   store [[REC]] [[V]], [[REC]]* [[TMP2]], align
466 // CHECK:   [[CAST_TMP:%.*]] = bitcast [[REC]]* [[TMP2]] to [[AGG]]*
467 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 0
468 // CHECK:   [[FIRST:%.*]] = load <4 x i32>, <4 x i32>* [[T0]], align
469 // CHECK:   [[T0:%.*]] = getelementptr inbounds [[AGG]], [[AGG]]* [[CAST_TMP]], i32 0, i32 1
470 // CHECK:   [[SECOND:%.*]] = load i32, i32* [[T0]], align
471 // CHECK:   call [[SWIFTCC]] void @take_int5(<4 x i32> [[FIRST]], i32 [[SECOND]])
472 // CHECK:   ret void
473 
474 typedef struct {
475   int x;
476   int3 v __attribute__((packed));
477 } misaligned_int3;
478 TEST(misaligned_int3)
479 // CHECK-LABEL: define{{.*}} swiftcc void @take_misaligned_int3(i64 %0, i64 %1)
480 
481 typedef struct {
482   float f0;
483 } struct_f1;
484 TEST(struct_f1)
485 // CHECK-LABEL: define{{.*}} swiftcc float @return_struct_f1()
486 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_f1(float %0)
487 
488 typedef struct {
489   float f0;
490   float f1;
491 } struct_f2;
492 TEST(struct_f2)
493 // CHECK-LABEL: define{{.*}} swiftcc { float, float } @return_struct_f2()
494 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_f2(float %0, float %1)
495 
496 typedef struct {
497   float f0;
498   float f1;
499   float f2;
500 } struct_f3;
501 TEST(struct_f3)
502 // CHECK-LABEL: define{{.*}} swiftcc { float, float, float } @return_struct_f3()
503 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_f3(float %0, float %1, float %2)
504 
505 typedef struct {
506   float f0;
507   float f1;
508   float f2;
509   float f3;
510 } struct_f4;
511 TEST(struct_f4)
512 // CHECK-LABEL: define{{.*}} swiftcc { float, float, float, float } @return_struct_f4()
513 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_f4(float %0, float %1, float %2, float %3)
514 
515 
516 typedef struct {
517   double d0;
518 } struct_d1;
519 TEST(struct_d1)
520 // CHECK-LABEL: define{{.*}} swiftcc double @return_struct_d1()
521 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_d1(double %0)
522 
523 typedef struct {
524   double d0;
525   double d1;
526 } struct_d2;
527 TEST(struct_d2)
528 
529 // CHECK-LABEL: define{{.*}} swiftcc { double, double } @return_struct_d2()
530 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_d2(double %0, double %1)
531 typedef struct {
532   double d0;
533   double d1;
534   double d2;
535 } struct_d3;
536 TEST(struct_d3)
537 // CHECK-LABEL: define{{.*}} swiftcc { double, double, double } @return_struct_d3()
538 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_d3(double %0, double %1, double %2)
539 
540 typedef struct {
541   double d0;
542   double d1;
543   double d2;
544   double d3;
545 } struct_d4;
546 TEST(struct_d4)
547 // CHECK-LABEL: define{{.*}} swiftcc { double, double, double, double } @return_struct_d4()
548 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_d4(double %0, double %1, double %2, double %3)
549 
550 typedef struct {
551   double d0;
552   double d1;
553   double d2;
554   double d3;
555   double d4;
556 } struct_d5;
557 TEST(struct_d5)
558 // CHECK: define{{.*}} swiftcc void @return_struct_d5([[STRUCT5:%.*]]* noalias sret([[STRUCT5]])
559 // CHECK: define{{.*}} swiftcc void @take_struct_d5([[STRUCT5]]
560 
561 typedef struct {
562   char c0;
563 } struct_c1;
564 TEST(struct_c1)
565 // CHECK-LABEL: define{{.*}} swiftcc i8 @return_struct_c1()
566 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_c1(i8 %0)
567 
568 typedef struct {
569   char c0;
570   char c1;
571 } struct_c2;
572 TEST(struct_c2)
573 // CHECK-LABEL: define{{.*}} swiftcc i16 @return_struct_c2()
574 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_c2(i16 %0)
575 //
576 
577 typedef struct {
578   char c0;
579   char c1;
580   char c2;
581 } struct_c3;
582 TEST(struct_c3)
583 // CHECK-LABEL: define{{.*}} swiftcc i32 @return_struct_c3()
584 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_c3(i32 %0)
585 
586 typedef struct {
587   char c0;
588   char c1;
589   char c2;
590   char c3;
591 } struct_c4;
592 TEST(struct_c4)
593 // CHECK-LABEL: define{{.*}} swiftcc i32 @return_struct_c4()
594 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_c4(i32 %0)
595 
596 typedef struct {
597   char c0;
598   char c1;
599   char c2;
600   char c3;
601   char c4;
602 } struct_c5;
603 TEST(struct_c5)
604 // CHECK-LABEL: define{{.*}} swiftcc i64 @return_struct_c5()
605 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_c5(i64 %0)
606 //
607 typedef struct {
608   char c0;
609   char c1;
610   char c2;
611   char c3;
612   char c4;
613   char c5;
614   char c6;
615   char c7;
616   char c8;
617 } struct_c9;
618 TEST(struct_c9)
619 // CHECK-LABEL: define{{.*}} swiftcc { i64, i8 } @return_struct_c9()
620 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_c9(i64 %0, i8 %1)
621 
622 typedef struct {
623   short s0;
624 } struct_s1;
625 TEST(struct_s1)
626 // CHECK-LABEL: define{{.*}} swiftcc i16 @return_struct_s1()
627 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_s1(i16 %0)
628 
629 typedef struct {
630   short s0;
631   short s1;
632 } struct_s2;
633 TEST(struct_s2)
634 // CHECK-LABEL: define{{.*}} swiftcc i32 @return_struct_s2()
635 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_s2(i32 %0)
636 //
637 
638 typedef struct {
639   short s0;
640   short s1;
641   short s2;
642 } struct_s3;
643 TEST(struct_s3)
644 // CHECK-LABEL: define{{.*}} swiftcc i64 @return_struct_s3()
645 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_s3(i64 %0)
646 
647 typedef struct {
648   short s0;
649   short s1;
650   short s2;
651   short s3;
652 } struct_s4;
653 TEST(struct_s4)
654 // CHECK-LABEL: define{{.*}} swiftcc i64 @return_struct_s4()
655 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_s4(i64 %0)
656 
657 typedef struct {
658   short s0;
659   short s1;
660   short s2;
661   short s3;
662   short s4;
663 } struct_s5;
664 TEST(struct_s5)
665 // CHECK-LABEL: define{{.*}} swiftcc { i64, i16 } @return_struct_s5()
666 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_s5(i64 %0, i16 %1)
667 
668 
669 typedef struct {
670   int i0;
671 } struct_i1;
672 TEST(struct_i1)
673 // CHECK-LABEL: define{{.*}} swiftcc i32 @return_struct_i1()
674 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_i1(i32 %0)
675 
676 typedef struct {
677   int i0;
678   int i1;
679 } struct_i2;
680 TEST(struct_i2)
681 // CHECK-LABEL: define{{.*}} swiftcc i64 @return_struct_i2()
682 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_i2(i64 %0)
683 
684 typedef struct {
685   int i0;
686   int i1;
687   int i2;
688 } struct_i3;
689 TEST(struct_i3)
690 // CHECK-LABEL: define{{.*}} swiftcc { i64, i32 } @return_struct_i3()
691 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_i3(i64 %0, i32 %1)
692 
693 typedef struct {
694   int i0;
695   int i1;
696   int i2;
697   int i3;
698 } struct_i4;
699 TEST(struct_i4)
700 // CHECK-LABEL: define{{.*}} swiftcc { i64, i64 } @return_struct_i4()
701 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_i4(i64 %0, i64 %1)
702 
703 typedef struct {
704   long long l0;
705 } struct_l1;
706 TEST(struct_l1)
707 // CHECK-LABEL: define{{.*}} swiftcc i64 @return_struct_l1()
708 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_l1(i64 %0)
709 
710 typedef struct {
711   long long l0;
712   long long l1;
713 } struct_l2;
714 TEST(struct_l2)
715 // CHECK-LABEL: define{{.*}} swiftcc { i64, i64 } @return_struct_l2()
716 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_l2(i64 %0, i64 %1)
717 
718 typedef struct {
719   long long l0;
720   long long l1;
721   long long l2;
722 } struct_l3;
723 TEST(struct_l3)
724 // CHECK-LABEL: define{{.*}} swiftcc { i64, i64, i64 } @return_struct_l3()
725 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_l3(i64 %0, i64 %1, i64 %2)
726 
727 typedef struct {
728   long long l0;
729   long long l1;
730   long long l2;
731   long long l3;
732 } struct_l4;
733 TEST(struct_l4)
734 // CHECK-LABEL: define{{.*}} swiftcc { i64, i64, i64, i64 } @return_struct_l4()
735 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_l4(i64 %0, i64 %1, i64 %2, i64 %3)
736 
737 typedef struct {
738   long long l0;
739   long long l1;
740   long long l2;
741   long long l3;
742   long long l4;
743 } struct_l5;
744 TEST(struct_l5)
745 // CHECK: define{{.*}} swiftcc void @return_struct_l5([[STRUCT5:%.*]]* noalias sret([[STRUCT5]])
746 // CHECK: define{{.*}} swiftcc void @take_struct_l5([[STRUCT5]]*
747 
748 typedef struct {
749   char16 c0;
750 } struct_vc1;
751 TEST(struct_vc1)
752 // CHECK-LABEL: define{{.*}} swiftcc <16 x i8> @return_struct_vc1()
753 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vc1(<16 x i8> %0)
754 
755 typedef struct {
756   char16 c0;
757   char16 c1;
758 } struct_vc2;
759 TEST(struct_vc2)
760 // CHECK-LABEL: define{{.*}} swiftcc { <16 x i8>, <16 x i8> } @return_struct_vc2()
761 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vc2(<16 x i8> %0, <16 x i8> %1)
762 
763 typedef struct {
764   char16 c0;
765   char16 c1;
766   char16 c2;
767 } struct_vc3;
768 TEST(struct_vc3)
769 // CHECK-LABEL: define{{.*}} swiftcc { <16 x i8>, <16 x i8>, <16 x i8> } @return_struct_vc3()
770 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vc3(<16 x i8> %0, <16 x i8> %1, <16 x i8> %2)
771 
772 typedef struct {
773   char16 c0;
774   char16 c1;
775   char16 c2;
776   char16 c3;
777 } struct_vc4;
778 TEST(struct_vc4)
779 // CHECK-LABEL: define{{.*}} swiftcc { <16 x i8>, <16 x i8>, <16 x i8>, <16 x i8> } @return_struct_vc4()
780 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vc4(<16 x i8> %0, <16 x i8> %1, <16 x i8> %2, <16 x i8> %3)
781 
782 typedef struct {
783   char16 c0;
784   char16 c1;
785   char16 c2;
786   char16 c3;
787   char16 c4;
788 } struct_vc5;
789 TEST(struct_vc5)
790 // CHECK: define{{.*}} swiftcc void @return_struct_vc5([[STRUCT:%.*]]* noalias sret([[STRUCT]])
791 // CHECK: define{{.*}} swiftcc void @take_struct_vc5([[STRUCT]]
792 
793 typedef struct {
794   short8 c0;
795 } struct_vs1;
796 TEST(struct_vs1)
797 // CHECK-LABEL: define{{.*}} swiftcc <8 x i16> @return_struct_vs1()
798 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vs1(<8 x i16> %0)
799 
800 typedef struct {
801   short8 c0;
802   short8 c1;
803 } struct_vs2;
804 TEST(struct_vs2)
805 // CHECK-LABEL: define{{.*}} swiftcc { <8 x i16>, <8 x i16> } @return_struct_vs2()
806 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vs2(<8 x i16> %0, <8 x i16> %1)
807 
808 typedef struct {
809   short8 c0;
810   short8 c1;
811   short8 c2;
812 } struct_vs3;
813 TEST(struct_vs3)
814 // CHECK-LABEL: define{{.*}} swiftcc { <8 x i16>, <8 x i16>, <8 x i16> } @return_struct_vs3()
815 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vs3(<8 x i16> %0, <8 x i16> %1, <8 x i16> %2)
816 
817 typedef struct {
818   short8 c0;
819   short8 c1;
820   short8 c2;
821   short8 c3;
822 } struct_vs4;
823 TEST(struct_vs4)
824 // CHECK-LABEL: define{{.*}} swiftcc { <8 x i16>, <8 x i16>, <8 x i16>, <8 x i16> } @return_struct_vs4()
825 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vs4(<8 x i16> %0, <8 x i16> %1, <8 x i16> %2, <8 x i16> %3)
826 
827 typedef struct {
828   short8 c0;
829   short8 c1;
830   short8 c2;
831   short8 c3;
832   short8 c4;
833 } struct_vs5;
834 TEST(struct_vs5)
835 // CHECK: define{{.*}} swiftcc void @return_struct_vs5([[STRUCT:%.*]]* noalias sret([[STRUCT]])
836 // CHECK: define{{.*}} swiftcc void @take_struct_vs5([[STRUCT]]
837 
838 typedef struct {
839   int4 c0;
840 } struct_vi1;
841 TEST(struct_vi1)
842 // CHECK-LABEL: define{{.*}} swiftcc <4 x i32> @return_struct_vi1()
843 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vi1(<4 x i32> %0)
844 
845 typedef struct {
846   int4 c0;
847   int4 c1;
848 } struct_vi2;
849 TEST(struct_vi2)
850 // CHECK-LABEL: define{{.*}} swiftcc { <4 x i32>, <4 x i32> } @return_struct_vi2()
851 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vi2(<4 x i32> %0, <4 x i32> %1)
852 
853 typedef struct {
854   int4 c0;
855   int4 c1;
856   int4 c2;
857 } struct_vi3;
858 TEST(struct_vi3)
859 // CHECK-LABEL: define{{.*}} swiftcc { <4 x i32>, <4 x i32>, <4 x i32> } @return_struct_vi3()
860 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vi3(<4 x i32> %0, <4 x i32> %1, <4 x i32> %2)
861 
862 typedef struct {
863   int4 c0;
864   int4 c1;
865   int4 c2;
866   int4 c3;
867 } struct_vi4;
868 TEST(struct_vi4)
869 // CHECK-LABEL: define{{.*}} swiftcc { <4 x i32>, <4 x i32>, <4 x i32>, <4 x i32> } @return_struct_vi4()
870 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vi4(<4 x i32> %0, <4 x i32> %1, <4 x i32> %2, <4 x i32> %3)
871 
872 typedef struct {
873   int4 c0;
874   int4 c1;
875   int4 c2;
876   int4 c3;
877   int4 c4;
878 } struct_vi5;
879 TEST(struct_vi5)
880 // CHECK: define{{.*}} swiftcc void @return_struct_vi5([[STRUCT:%.*]]* noalias sret([[STRUCT]])
881 // CHECK: define{{.*}} swiftcc void @take_struct_vi5([[STRUCT]]
882 
883 typedef struct {
884   long2 c0;
885 } struct_vl1;
886 TEST(struct_vl1)
887 // CHECK-LABEL: define{{.*}} swiftcc <2 x i64> @return_struct_vl1()
888 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vl1(<2 x i64> %0)
889 
890 typedef struct {
891   long2 c0;
892   long2 c1;
893   long2 c2;
894   long2 c3;
895 } struct_vl4;
896 TEST(struct_vl4)
897 // CHECK-LABEL: define{{.*}} swiftcc { <2 x i64>, <2 x i64>, <2 x i64>, <2 x i64> } @return_struct_vl4()
898 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vl4(<2 x i64> %0, <2 x i64> %1, <2 x i64> %2, <2 x i64> %3)
899 
900 typedef struct {
901   long2 c0;
902   long2 c1;
903   long2 c2;
904   long2 c3;
905   long2 c4;
906 } struct_vl5;
907 TEST(struct_vl5)
908 // CHECK: define{{.*}} swiftcc void @return_struct_vl5([[STRUCT:%.*]]* noalias sret([[STRUCT]])
909 // CHECK: define{{.*}} swiftcc void @take_struct_vl5([[STRUCT]]
910 
911 typedef struct {
912   double2 c0;
913 } struct_vd1;
914 TEST(struct_vd1)
915 // CHECK-LABEL: define{{.*}} swiftcc <2 x double> @return_struct_vd1()
916 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vd1(<2 x double> %0)
917 
918 typedef struct {
919   double2 c0;
920   double2 c1;
921   double2 c2;
922   double2 c3;
923 } struct_vd4;
924 TEST(struct_vd4)
925 // CHECK-LABEL: define{{.*}} swiftcc { <2 x double>, <2 x double>, <2 x double>, <2 x double> } @return_struct_vd4()
926 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vd4(<2 x double> %0, <2 x double> %1, <2 x double> %2, <2 x double> %3)
927 
928 typedef struct {
929   double2 c0;
930   double2 c1;
931   double2 c2;
932   double2 c3;
933   double2 c4;
934 } struct_vd5;
935 TEST(struct_vd5)
936 // CHECK: define{{.*}} swiftcc void @return_struct_vd5([[STRUCT:%.*]]* noalias sret([[STRUCT]])
937 // CHECK: define{{.*}} swiftcc void @take_struct_vd5([[STRUCT]]
938 
939 typedef struct {
940   double4 c0;
941 } struct_vd41;
942 TEST(struct_vd41)
943 // CHECK-LABEL: define{{.*}} swiftcc { <2 x double>, <2 x double> } @return_struct_vd41()
944 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vd41(<2 x double> %0, <2 x double> %1)
945 
946 typedef struct {
947   double4 c0;
948   double4 c1;
949 } struct_vd42;
950 TEST(struct_vd42)
951 // CHECK-LABEL: define{{.*}} swiftcc { <2 x double>, <2 x double>, <2 x double>, <2 x double> } @return_struct_vd42()
952 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vd42(<2 x double> %0, <2 x double> %1, <2 x double> %2, <2 x double> %3)
953 
954 typedef struct {
955   double4 c0;
956   double4 c1;
957   double4 c2;
958 } struct_vd43;
959 TEST(struct_vd43)
960 // CHECK: define{{.*}} swiftcc void @return_struct_vd43([[STRUCT:%.*]]* noalias sret([[STRUCT]])
961 // CHECK: define{{.*}} swiftcc void @take_struct_vd43([[STRUCT]]
962 
963 typedef struct {
964   float4 c0;
965 } struct_vf1;
966 TEST(struct_vf1)
967 // CHECK-LABEL: define{{.*}} swiftcc <4 x float> @return_struct_vf1()
968 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vf1(<4 x float> %0)
969 
970 typedef struct {
971   float4 c0;
972   float4 c1;
973 } struct_vf2;
974 TEST(struct_vf2)
975 // CHECK-LABEL: define{{.*}} swiftcc { <4 x float>, <4 x float> } @return_struct_vf2()
976 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vf2(<4 x float> %0, <4 x float> %1)
977 
978 typedef struct {
979   float4 c0;
980   float4 c1;
981   float4 c2;
982   float4 c3;
983 } struct_vf4;
984 TEST(struct_vf4)
985 // CHECK-LABEL: define{{.*}} swiftcc { <4 x float>, <4 x float>, <4 x float>, <4 x float> } @return_struct_vf4()
986 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vf4(<4 x float> %0, <4 x float> %1, <4 x float> %2, <4 x float> %3)
987 
988 typedef struct {
989   float4 c0;
990   float4 c1;
991   float4 c2;
992   float4 c3;
993   float4 c4;
994 } struct_vf5;
995 TEST(struct_vf5)
996 // CHECK: define{{.*}} swiftcc void @return_struct_vf5([[STRUCT:%.*]]* noalias sret([[STRUCT]])
997 // CHECK: define{{.*}} swiftcc void @take_struct_vf5([[STRUCT]]
998 
999 typedef struct {
1000   float8 c0;
1001 } struct_vf81;
1002 TEST(struct_vf81)
1003 // CHECK-LABEL: define{{.*}} swiftcc { <4 x float>, <4 x float> } @return_struct_vf81()
1004 // CHECK-LABEL: define{{.*}} swiftcc void @take_struct_vf81(<4 x float> %0, <4 x float> %1)
1005 
1006 // Don't crash.
1007 typedef union {
1008 int4 v[2];
1009 struct {
1010   int LSW;
1011   int d7;
1012   int d6;
1013   int d5;
1014   int d4;
1015   int d3;
1016   int d2;
1017   int MSW;
1018 } s;
1019 } union_het_vecint;
1020 TEST(union_het_vecint)
1021 // CHECK: define{{.*}} swiftcc void @return_union_het_vecint([[UNION:%.*]]* noalias sret([[UNION]])
1022 // CHECK: define{{.*}} swiftcc void @take_union_het_vecint([[UNION]]*
1023 
1024 typedef struct {
1025   float3 f3;
1026 } struct_v1f3;
1027 TEST(struct_v1f3)
1028 // ARM64-LABEL: define{{.*}} swiftcc { <2 x float>, float } @return_struct_v1f3()
1029 // ARM64-LABEL: define{{.*}} swiftcc void @take_struct_v1f3(<2 x float> %0, float %1)
1030 
1031 typedef struct {
1032   int3 vect;
1033   unsigned long long val;
1034 } __attribute__((packed)) padded_alloc_size_vector;
1035 TEST(padded_alloc_size_vector)
1036 // X86-64-LABEL: take_padded_alloc_size_vector(<3 x i32> %0, i64 %1)
1037 // X86-64-NOT: [4 x i8]
1038 // x86-64: ret void
1039 
1040 typedef union {
1041   float f1;
1042   float3 fv2;
1043 } union_hom_fp_partial2;
TEST(union_hom_fp_partial2)1044 TEST(union_hom_fp_partial2)
1045 // X86-64-LABEL: take_union_hom_fp_partial2(float %0, float %1, float %2)
1046 // ARM64-LABEL: take_union_hom_fp_partial2(float %0, float %1, float %2)
1047 
1048 // At one point, we emitted lifetime.ends without a matching lifetime.start for
1049 // CoerceAndExpanded args. Since we're not performing optimizations, neither
1050 // intrinsic should be emitted.
1051 // CHECK-LABEL: define{{.*}} void @no_lifetime_markers
1052 void no_lifetime_markers() {
1053   // CHECK-NOT: call void @llvm.lifetime.
1054   take_int5(return_int5());
1055 }
1056 
1057 typedef struct {
1058   unsigned long long a;
1059   unsigned long long b;
1060 } double_word;
1061 
1062 typedef struct {
1063   _Atomic(double_word) a;
1064 } atomic_double_word;
1065 
1066 // CHECK-LABEL: use_atomic(i64 %0, i64 %1)
use_atomic(atomic_double_word a)1067 SWIFTCALL void use_atomic(atomic_double_word a) {}
1068 
1069 typedef struct {
1070   unsigned long long a;
1071   unsigned char b;
1072 } __attribute__((packed)) packed;
1073 
1074 typedef struct {
1075   _Atomic(packed) a;
1076 } atomic_padded;
1077 
1078 // CHECK-LABEL: use_atomic_padded(i64 %0, i64 %1)
use_atomic_padded(atomic_padded a)1079 SWIFTCALL void use_atomic_padded(atomic_padded a) {}
1080