1 // RUN: %clang_cc1 -faltivec -triple powerpc64le-unknown-linux-gnu -emit-llvm -o - %s | FileCheck %s
2
3 // Test homogeneous float aggregate passing and returning.
4
5 struct f1 { float f[1]; };
6 struct f2 { float f[2]; };
7 struct f3 { float f[3]; };
8 struct f4 { float f[4]; };
9 struct f5 { float f[5]; };
10 struct f6 { float f[6]; };
11 struct f7 { float f[7]; };
12 struct f8 { float f[8]; };
13 struct f9 { float f[9]; };
14
15 struct fab { float a; float b; };
16 struct fabc { float a; float b; float c; };
17
18 struct f2a2b { float a[2]; float b[2]; };
19
20 // CHECK: define [1 x float] @func_f1(float inreg %x.coerce)
func_f1(struct f1 x)21 struct f1 func_f1(struct f1 x) { return x; }
22
23 // CHECK: define [2 x float] @func_f2([2 x float] %x.coerce)
func_f2(struct f2 x)24 struct f2 func_f2(struct f2 x) { return x; }
25
26 // CHECK: define [3 x float] @func_f3([3 x float] %x.coerce)
func_f3(struct f3 x)27 struct f3 func_f3(struct f3 x) { return x; }
28
29 // CHECK: define [4 x float] @func_f4([4 x float] %x.coerce)
func_f4(struct f4 x)30 struct f4 func_f4(struct f4 x) { return x; }
31
32 // CHECK: define [5 x float] @func_f5([5 x float] %x.coerce)
func_f5(struct f5 x)33 struct f5 func_f5(struct f5 x) { return x; }
34
35 // CHECK: define [6 x float] @func_f6([6 x float] %x.coerce)
func_f6(struct f6 x)36 struct f6 func_f6(struct f6 x) { return x; }
37
38 // CHECK: define [7 x float] @func_f7([7 x float] %x.coerce)
func_f7(struct f7 x)39 struct f7 func_f7(struct f7 x) { return x; }
40
41 // CHECK: define [8 x float] @func_f8([8 x float] %x.coerce)
func_f8(struct f8 x)42 struct f8 func_f8(struct f8 x) { return x; }
43
44 // CHECK: define void @func_f9(%struct.f9* noalias sret %agg.result, [5 x i64] %x.coerce)
func_f9(struct f9 x)45 struct f9 func_f9(struct f9 x) { return x; }
46
47 // CHECK: define [2 x float] @func_fab([2 x float] %x.coerce)
func_fab(struct fab x)48 struct fab func_fab(struct fab x) { return x; }
49
50 // CHECK: define [3 x float] @func_fabc([3 x float] %x.coerce)
func_fabc(struct fabc x)51 struct fabc func_fabc(struct fabc x) { return x; }
52
53 // CHECK: define [4 x float] @func_f2a2b([4 x float] %x.coerce)
func_f2a2b(struct f2a2b x)54 struct f2a2b func_f2a2b(struct f2a2b x) { return x; }
55
56 // CHECK-LABEL: @call_f1
57 // CHECK: %[[TMP:[^ ]+]] = load float* getelementptr inbounds (%struct.f1* @global_f1, i32 0, i32 0, i32 0), align 1
58 // CHECK: call [1 x float] @func_f1(float inreg %[[TMP]])
59 struct f1 global_f1;
call_f1(void)60 void call_f1(void) { global_f1 = func_f1(global_f1); }
61
62 // CHECK-LABEL: @call_f2
63 // CHECK: %[[TMP:[^ ]+]] = load [2 x float]* getelementptr inbounds (%struct.f2* @global_f2, i32 0, i32 0), align 1
64 // CHECK: call [2 x float] @func_f2([2 x float] %[[TMP]])
65 struct f2 global_f2;
call_f2(void)66 void call_f2(void) { global_f2 = func_f2(global_f2); }
67
68 // CHECK-LABEL: @call_f3
69 // CHECK: %[[TMP:[^ ]+]] = load [3 x float]* getelementptr inbounds (%struct.f3* @global_f3, i32 0, i32 0), align 1
70 // CHECK: call [3 x float] @func_f3([3 x float] %[[TMP]])
71 struct f3 global_f3;
call_f3(void)72 void call_f3(void) { global_f3 = func_f3(global_f3); }
73
74 // CHECK-LABEL: @call_f4
75 // CHECK: %[[TMP:[^ ]+]] = load [4 x float]* getelementptr inbounds (%struct.f4* @global_f4, i32 0, i32 0), align 1
76 // CHECK: call [4 x float] @func_f4([4 x float] %[[TMP]])
77 struct f4 global_f4;
call_f4(void)78 void call_f4(void) { global_f4 = func_f4(global_f4); }
79
80 // CHECK-LABEL: @call_f5
81 // CHECK: %[[TMP:[^ ]+]] = load [5 x float]* getelementptr inbounds (%struct.f5* @global_f5, i32 0, i32 0), align 1
82 // CHECK: call [5 x float] @func_f5([5 x float] %[[TMP]])
83 struct f5 global_f5;
call_f5(void)84 void call_f5(void) { global_f5 = func_f5(global_f5); }
85
86 // CHECK-LABEL: @call_f6
87 // CHECK: %[[TMP:[^ ]+]] = load [6 x float]* getelementptr inbounds (%struct.f6* @global_f6, i32 0, i32 0), align 1
88 // CHECK: call [6 x float] @func_f6([6 x float] %[[TMP]])
89 struct f6 global_f6;
call_f6(void)90 void call_f6(void) { global_f6 = func_f6(global_f6); }
91
92 // CHECK-LABEL: @call_f7
93 // CHECK: %[[TMP:[^ ]+]] = load [7 x float]* getelementptr inbounds (%struct.f7* @global_f7, i32 0, i32 0), align 1
94 // CHECK: call [7 x float] @func_f7([7 x float] %[[TMP]])
95 struct f7 global_f7;
call_f7(void)96 void call_f7(void) { global_f7 = func_f7(global_f7); }
97
98 // CHECK-LABEL: @call_f8
99 // CHECK: %[[TMP:[^ ]+]] = load [8 x float]* getelementptr inbounds (%struct.f8* @global_f8, i32 0, i32 0), align 1
100 // CHECK: call [8 x float] @func_f8([8 x float] %[[TMP]])
101 struct f8 global_f8;
call_f8(void)102 void call_f8(void) { global_f8 = func_f8(global_f8); }
103
104 // CHECK-LABEL: @call_f9
105 // CHECK: %[[TMP1:[^ ]+]] = alloca [5 x i64]
106 // CHECK: %[[TMP2:[^ ]+]] = bitcast [5 x i64]* %[[TMP1]] to i8*
107 // CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* %[[TMP2]], i8* bitcast (%struct.f9* @global_f9 to i8*), i64 36, i32 1, i1 false)
108 // CHECK: %[[TMP3:[^ ]+]] = load [5 x i64]* %[[TMP1]]
109 // CHECK: call void @func_f9(%struct.f9* sret %{{[^ ]+}}, [5 x i64] %[[TMP3]])
110 struct f9 global_f9;
call_f9(void)111 void call_f9(void) { global_f9 = func_f9(global_f9); }
112
113 // CHECK-LABEL: @call_fab
114 // CHECK: %[[TMP:[^ ]+]] = load [2 x float]* bitcast (%struct.fab* @global_fab to [2 x float]*)
115 // CHECK: call [2 x float] @func_fab([2 x float] %[[TMP]])
116 struct fab global_fab;
call_fab(void)117 void call_fab(void) { global_fab = func_fab(global_fab); }
118
119 // CHECK-LABEL: @call_fabc
120 // CHECK: %[[TMP:[^ ]+]] = load [3 x float]* bitcast (%struct.fabc* @global_fabc to [3 x float]*)
121 // CHECK: call [3 x float] @func_fabc([3 x float] %[[TMP]])
122 struct fabc global_fabc;
call_fabc(void)123 void call_fabc(void) { global_fabc = func_fabc(global_fabc); }
124
125
126 // Test homogeneous vector aggregate passing and returning.
127
128 struct v1 { vector int v[1]; };
129 struct v2 { vector int v[2]; };
130 struct v3 { vector int v[3]; };
131 struct v4 { vector int v[4]; };
132 struct v5 { vector int v[5]; };
133 struct v6 { vector int v[6]; };
134 struct v7 { vector int v[7]; };
135 struct v8 { vector int v[8]; };
136 struct v9 { vector int v[9]; };
137
138 struct vab { vector int a; vector int b; };
139 struct vabc { vector int a; vector int b; vector int c; };
140
141 // CHECK: define [1 x <4 x i32>] @func_v1(<4 x i32> inreg %x.coerce)
func_v1(struct v1 x)142 struct v1 func_v1(struct v1 x) { return x; }
143
144 // CHECK: define [2 x <4 x i32>] @func_v2([2 x <4 x i32>] %x.coerce)
func_v2(struct v2 x)145 struct v2 func_v2(struct v2 x) { return x; }
146
147 // CHECK: define [3 x <4 x i32>] @func_v3([3 x <4 x i32>] %x.coerce)
func_v3(struct v3 x)148 struct v3 func_v3(struct v3 x) { return x; }
149
150 // CHECK: define [4 x <4 x i32>] @func_v4([4 x <4 x i32>] %x.coerce)
func_v4(struct v4 x)151 struct v4 func_v4(struct v4 x) { return x; }
152
153 // CHECK: define [5 x <4 x i32>] @func_v5([5 x <4 x i32>] %x.coerce)
func_v5(struct v5 x)154 struct v5 func_v5(struct v5 x) { return x; }
155
156 // CHECK: define [6 x <4 x i32>] @func_v6([6 x <4 x i32>] %x.coerce)
func_v6(struct v6 x)157 struct v6 func_v6(struct v6 x) { return x; }
158
159 // CHECK: define [7 x <4 x i32>] @func_v7([7 x <4 x i32>] %x.coerce)
func_v7(struct v7 x)160 struct v7 func_v7(struct v7 x) { return x; }
161
162 // CHECK: define [8 x <4 x i32>] @func_v8([8 x <4 x i32>] %x.coerce)
func_v8(struct v8 x)163 struct v8 func_v8(struct v8 x) { return x; }
164
165 // CHECK: define void @func_v9(%struct.v9* noalias sret %agg.result, %struct.v9* byval align 16 %x)
func_v9(struct v9 x)166 struct v9 func_v9(struct v9 x) { return x; }
167
168 // CHECK: define [2 x <4 x i32>] @func_vab([2 x <4 x i32>] %x.coerce)
func_vab(struct vab x)169 struct vab func_vab(struct vab x) { return x; }
170
171 // CHECK: define [3 x <4 x i32>] @func_vabc([3 x <4 x i32>] %x.coerce)
func_vabc(struct vabc x)172 struct vabc func_vabc(struct vabc x) { return x; }
173
174 // CHECK-LABEL: @call_v1
175 // CHECK: %[[TMP:[^ ]+]] = load <4 x i32>* getelementptr inbounds (%struct.v1* @global_v1, i32 0, i32 0, i32 0), align 1
176 // CHECK: call [1 x <4 x i32>] @func_v1(<4 x i32> inreg %[[TMP]])
177 struct v1 global_v1;
call_v1(void)178 void call_v1(void) { global_v1 = func_v1(global_v1); }
179
180 // CHECK-LABEL: @call_v2
181 // CHECK: %[[TMP:[^ ]+]] = load [2 x <4 x i32>]* getelementptr inbounds (%struct.v2* @global_v2, i32 0, i32 0), align 1
182 // CHECK: call [2 x <4 x i32>] @func_v2([2 x <4 x i32>] %[[TMP]])
183 struct v2 global_v2;
call_v2(void)184 void call_v2(void) { global_v2 = func_v2(global_v2); }
185
186 // CHECK-LABEL: @call_v3
187 // CHECK: %[[TMP:[^ ]+]] = load [3 x <4 x i32>]* getelementptr inbounds (%struct.v3* @global_v3, i32 0, i32 0), align 1
188 // CHECK: call [3 x <4 x i32>] @func_v3([3 x <4 x i32>] %[[TMP]])
189 struct v3 global_v3;
call_v3(void)190 void call_v3(void) { global_v3 = func_v3(global_v3); }
191
192 // CHECK-LABEL: @call_v4
193 // CHECK: %[[TMP:[^ ]+]] = load [4 x <4 x i32>]* getelementptr inbounds (%struct.v4* @global_v4, i32 0, i32 0), align 1
194 // CHECK: call [4 x <4 x i32>] @func_v4([4 x <4 x i32>] %[[TMP]])
195 struct v4 global_v4;
call_v4(void)196 void call_v4(void) { global_v4 = func_v4(global_v4); }
197
198 // CHECK-LABEL: @call_v5
199 // CHECK: %[[TMP:[^ ]+]] = load [5 x <4 x i32>]* getelementptr inbounds (%struct.v5* @global_v5, i32 0, i32 0), align 1
200 // CHECK: call [5 x <4 x i32>] @func_v5([5 x <4 x i32>] %[[TMP]])
201 struct v5 global_v5;
call_v5(void)202 void call_v5(void) { global_v5 = func_v5(global_v5); }
203
204 // CHECK-LABEL: @call_v6
205 // CHECK: %[[TMP:[^ ]+]] = load [6 x <4 x i32>]* getelementptr inbounds (%struct.v6* @global_v6, i32 0, i32 0), align 1
206 // CHECK: call [6 x <4 x i32>] @func_v6([6 x <4 x i32>] %[[TMP]])
207 struct v6 global_v6;
call_v6(void)208 void call_v6(void) { global_v6 = func_v6(global_v6); }
209
210 // CHECK-LABEL: @call_v7
211 // CHECK: %[[TMP:[^ ]+]] = load [7 x <4 x i32>]* getelementptr inbounds (%struct.v7* @global_v7, i32 0, i32 0), align 1
212 // CHECK: call [7 x <4 x i32>] @func_v7([7 x <4 x i32>] %[[TMP]])
213 struct v7 global_v7;
call_v7(void)214 void call_v7(void) { global_v7 = func_v7(global_v7); }
215
216 // CHECK-LABEL: @call_v8
217 // CHECK: %[[TMP:[^ ]+]] = load [8 x <4 x i32>]* getelementptr inbounds (%struct.v8* @global_v8, i32 0, i32 0), align 1
218 // CHECK: call [8 x <4 x i32>] @func_v8([8 x <4 x i32>] %[[TMP]])
219 struct v8 global_v8;
call_v8(void)220 void call_v8(void) { global_v8 = func_v8(global_v8); }
221
222 // CHECK-LABEL: @call_v9
223 // CHECK: call void @func_v9(%struct.v9* sret %{{[^ ]+}}, %struct.v9* byval align 16 @global_v9)
224 struct v9 global_v9;
call_v9(void)225 void call_v9(void) { global_v9 = func_v9(global_v9); }
226
227 // CHECK-LABEL: @call_vab
228 // CHECK: %[[TMP:[^ ]+]] = load [2 x <4 x i32>]* bitcast (%struct.vab* @global_vab to [2 x <4 x i32>]*)
229 // CHECK: call [2 x <4 x i32>] @func_vab([2 x <4 x i32>] %[[TMP]])
230 struct vab global_vab;
call_vab(void)231 void call_vab(void) { global_vab = func_vab(global_vab); }
232
233 // CHECK-LABEL: @call_vabc
234 // CHECK: %[[TMP:[^ ]+]] = load [3 x <4 x i32>]* bitcast (%struct.vabc* @global_vabc to [3 x <4 x i32>]*)
235 // CHECK: call [3 x <4 x i32>] @func_vabc([3 x <4 x i32>] %[[TMP]])
236 struct vabc global_vabc;
call_vabc(void)237 void call_vabc(void) { global_vabc = func_vabc(global_vabc); }
238
239
240 // As clang extension, non-power-of-two vectors may also be part of
241 // homogeneous aggregates.
242
243 typedef float float3 __attribute__((vector_size (12)));
244
245 struct v3f1 { float3 v[1]; };
246 struct v3f2 { float3 v[2]; };
247 struct v3f3 { float3 v[3]; };
248 struct v3f4 { float3 v[4]; };
249 struct v3f5 { float3 v[5]; };
250 struct v3f6 { float3 v[6]; };
251 struct v3f7 { float3 v[7]; };
252 struct v3f8 { float3 v[8]; };
253 struct v3f9 { float3 v[9]; };
254
255 struct v3fab { float3 a; float3 b; };
256 struct v3fabc { float3 a; float3 b; float3 c; };
257
258 // CHECK: define [1 x <3 x float>] @func_v3f1(<3 x float> inreg %x.coerce)
func_v3f1(struct v3f1 x)259 struct v3f1 func_v3f1(struct v3f1 x) { return x; }
260
261 // CHECK: define [2 x <3 x float>] @func_v3f2([2 x <3 x float>] %x.coerce)
func_v3f2(struct v3f2 x)262 struct v3f2 func_v3f2(struct v3f2 x) { return x; }
263
264 // CHECK: define [3 x <3 x float>] @func_v3f3([3 x <3 x float>] %x.coerce)
func_v3f3(struct v3f3 x)265 struct v3f3 func_v3f3(struct v3f3 x) { return x; }
266
267 // CHECK: define [4 x <3 x float>] @func_v3f4([4 x <3 x float>] %x.coerce)
func_v3f4(struct v3f4 x)268 struct v3f4 func_v3f4(struct v3f4 x) { return x; }
269
270 // CHECK: define [5 x <3 x float>] @func_v3f5([5 x <3 x float>] %x.coerce)
func_v3f5(struct v3f5 x)271 struct v3f5 func_v3f5(struct v3f5 x) { return x; }
272
273 // CHECK: define [6 x <3 x float>] @func_v3f6([6 x <3 x float>] %x.coerce)
func_v3f6(struct v3f6 x)274 struct v3f6 func_v3f6(struct v3f6 x) { return x; }
275
276 // CHECK: define [7 x <3 x float>] @func_v3f7([7 x <3 x float>] %x.coerce)
func_v3f7(struct v3f7 x)277 struct v3f7 func_v3f7(struct v3f7 x) { return x; }
278
279 // CHECK: define [8 x <3 x float>] @func_v3f8([8 x <3 x float>] %x.coerce)
func_v3f8(struct v3f8 x)280 struct v3f8 func_v3f8(struct v3f8 x) { return x; }
281
282 // CHECK: define void @func_v3f9(%struct.v3f9* noalias sret %agg.result, %struct.v3f9* byval align 16 %x)
func_v3f9(struct v3f9 x)283 struct v3f9 func_v3f9(struct v3f9 x) { return x; }
284
285 // CHECK: define [2 x <3 x float>] @func_v3fab([2 x <3 x float>] %x.coerce)
func_v3fab(struct v3fab x)286 struct v3fab func_v3fab(struct v3fab x) { return x; }
287
288 // CHECK: define [3 x <3 x float>] @func_v3fabc([3 x <3 x float>] %x.coerce)
func_v3fabc(struct v3fabc x)289 struct v3fabc func_v3fabc(struct v3fabc x) { return x; }
290
291 // CHECK-LABEL: @call_v3f1
292 // CHECK: %[[TMP:[^ ]+]] = load <3 x float>* getelementptr inbounds (%struct.v3f1* @global_v3f1, i32 0, i32 0, i32 0), align 1
293 // CHECK: call [1 x <3 x float>] @func_v3f1(<3 x float> inreg %[[TMP]])
294 struct v3f1 global_v3f1;
call_v3f1(void)295 void call_v3f1(void) { global_v3f1 = func_v3f1(global_v3f1); }
296
297 // CHECK-LABEL: @call_v3f2
298 // CHECK: %[[TMP:[^ ]+]] = load [2 x <3 x float>]* getelementptr inbounds (%struct.v3f2* @global_v3f2, i32 0, i32 0), align 1
299 // CHECK: call [2 x <3 x float>] @func_v3f2([2 x <3 x float>] %[[TMP]])
300 struct v3f2 global_v3f2;
call_v3f2(void)301 void call_v3f2(void) { global_v3f2 = func_v3f2(global_v3f2); }
302
303 // CHECK-LABEL: @call_v3f3
304 // CHECK: %[[TMP:[^ ]+]] = load [3 x <3 x float>]* getelementptr inbounds (%struct.v3f3* @global_v3f3, i32 0, i32 0), align 1
305 // CHECK: call [3 x <3 x float>] @func_v3f3([3 x <3 x float>] %[[TMP]])
306 struct v3f3 global_v3f3;
call_v3f3(void)307 void call_v3f3(void) { global_v3f3 = func_v3f3(global_v3f3); }
308
309 // CHECK-LABEL: @call_v3f4
310 // CHECK: %[[TMP:[^ ]+]] = load [4 x <3 x float>]* getelementptr inbounds (%struct.v3f4* @global_v3f4, i32 0, i32 0), align 1
311 // CHECK: call [4 x <3 x float>] @func_v3f4([4 x <3 x float>] %[[TMP]])
312 struct v3f4 global_v3f4;
call_v3f4(void)313 void call_v3f4(void) { global_v3f4 = func_v3f4(global_v3f4); }
314
315 // CHECK-LABEL: @call_v3f5
316 // CHECK: %[[TMP:[^ ]+]] = load [5 x <3 x float>]* getelementptr inbounds (%struct.v3f5* @global_v3f5, i32 0, i32 0), align 1
317 // CHECK: call [5 x <3 x float>] @func_v3f5([5 x <3 x float>] %[[TMP]])
318 struct v3f5 global_v3f5;
call_v3f5(void)319 void call_v3f5(void) { global_v3f5 = func_v3f5(global_v3f5); }
320
321 // CHECK-LABEL: @call_v3f6
322 // CHECK: %[[TMP:[^ ]+]] = load [6 x <3 x float>]* getelementptr inbounds (%struct.v3f6* @global_v3f6, i32 0, i32 0), align 1
323 // CHECK: call [6 x <3 x float>] @func_v3f6([6 x <3 x float>] %[[TMP]])
324 struct v3f6 global_v3f6;
call_v3f6(void)325 void call_v3f6(void) { global_v3f6 = func_v3f6(global_v3f6); }
326
327 // CHECK-LABEL: @call_v3f7
328 // CHECK: %[[TMP:[^ ]+]] = load [7 x <3 x float>]* getelementptr inbounds (%struct.v3f7* @global_v3f7, i32 0, i32 0), align 1
329 // CHECK: call [7 x <3 x float>] @func_v3f7([7 x <3 x float>] %[[TMP]])
330 struct v3f7 global_v3f7;
call_v3f7(void)331 void call_v3f7(void) { global_v3f7 = func_v3f7(global_v3f7); }
332
333 // CHECK-LABEL: @call_v3f8
334 // CHECK: %[[TMP:[^ ]+]] = load [8 x <3 x float>]* getelementptr inbounds (%struct.v3f8* @global_v3f8, i32 0, i32 0), align 1
335 // CHECK: call [8 x <3 x float>] @func_v3f8([8 x <3 x float>] %[[TMP]])
336 struct v3f8 global_v3f8;
call_v3f8(void)337 void call_v3f8(void) { global_v3f8 = func_v3f8(global_v3f8); }
338
339 // CHECK-LABEL: @call_v3f9
340 // CHECK: call void @func_v3f9(%struct.v3f9* sret %{{[^ ]+}}, %struct.v3f9* byval align 16 @global_v3f9)
341 struct v3f9 global_v3f9;
call_v3f9(void)342 void call_v3f9(void) { global_v3f9 = func_v3f9(global_v3f9); }
343
344 // CHECK-LABEL: @call_v3fab
345 // CHECK: %[[TMP:[^ ]+]] = load [2 x <3 x float>]* bitcast (%struct.v3fab* @global_v3fab to [2 x <3 x float>]*)
346 // CHECK: call [2 x <3 x float>] @func_v3fab([2 x <3 x float>] %[[TMP]])
347 struct v3fab global_v3fab;
call_v3fab(void)348 void call_v3fab(void) { global_v3fab = func_v3fab(global_v3fab); }
349
350 // CHECK-LABEL: @call_v3fabc
351 // CHECK: %[[TMP:[^ ]+]] = load [3 x <3 x float>]* bitcast (%struct.v3fabc* @global_v3fabc to [3 x <3 x float>]*)
352 // CHECK: call [3 x <3 x float>] @func_v3fabc([3 x <3 x float>] %[[TMP]])
353 struct v3fabc global_v3fabc;
call_v3fabc(void)354 void call_v3fabc(void) { global_v3fabc = func_v3fabc(global_v3fabc); }
355
356
357 // Test returning small aggregates.
358
359 struct s1 { char c[1]; };
360 struct s2 { char c[2]; };
361 struct s3 { char c[3]; };
362 struct s4 { char c[4]; };
363 struct s5 { char c[5]; };
364 struct s6 { char c[6]; };
365 struct s7 { char c[7]; };
366 struct s8 { char c[8]; };
367 struct s9 { char c[9]; };
368 struct s16 { char c[16]; };
369 struct s17 { char c[17]; };
370
371 // CHECK: define i8 @ret_s1()
ret_s1()372 struct s1 ret_s1() {
373 return (struct s1) { 17 };
374 }
375
376 // CHECK: define i16 @ret_s2()
ret_s2()377 struct s2 ret_s2() {
378 return (struct s2) { 17, 18 };
379 }
380
381 // CHECK: define i24 @ret_s3()
ret_s3()382 struct s3 ret_s3() {
383 return (struct s3) { 17, 18, 19 };
384 }
385
386 // CHECK: define i32 @ret_s4()
ret_s4()387 struct s4 ret_s4() {
388 return (struct s4) { 17, 18, 19, 20 };
389 }
390
391 // CHECK: define i40 @ret_s5()
ret_s5()392 struct s5 ret_s5() {
393 return (struct s5) { 17, 18, 19, 20, 21 };
394 }
395
396 // CHECK: define i48 @ret_s6()
ret_s6()397 struct s6 ret_s6() {
398 return (struct s6) { 17, 18, 19, 20, 21, 22 };
399 }
400
401 // CHECK: define i56 @ret_s7()
ret_s7()402 struct s7 ret_s7() {
403 return (struct s7) { 17, 18, 19, 20, 21, 22, 23 };
404 }
405
406 // CHECK: define i64 @ret_s8()
ret_s8()407 struct s8 ret_s8() {
408 return (struct s8) { 17, 18, 19, 20, 21, 22, 23, 24 };
409 }
410
411 // CHECK: define { i64, i64 } @ret_s9()
ret_s9()412 struct s9 ret_s9() {
413 return (struct s9) { 17, 18, 19, 20, 21, 22, 23, 24, 25 };
414 }
415
416 // CHECK: define { i64, i64 } @ret_s16()
ret_s16()417 struct s16 ret_s16() {
418 return (struct s16) { 17, 18, 19, 20, 21, 22, 23, 24,
419 25, 26, 27, 28, 29, 30, 31, 32 };
420 }
421
422 // CHECK: define void @ret_s17(%struct.s17*
ret_s17()423 struct s17 ret_s17() {
424 return (struct s17) { 17, 18, 19, 20, 21, 22, 23, 24,
425 25, 26, 27, 28, 29, 30, 31, 32, 33 };
426 }
427
428