|
252
|
1 // RUN: %clang_cc1 -triple arm64-apple-ios11 -fobjc-arc -fblocks -fobjc-runtime=ios-11.0 -emit-llvm -o - -DUSESTRUCT %s | FileCheck %s
|
|
150
|
2
|
|
252
|
3 // RUN: %clang_cc1 -triple arm64-apple-ios11 -fobjc-arc -fblocks -fobjc-runtime=ios-11.0 -emit-pch -o %t %s
|
|
|
4 // RUN: %clang_cc1 -triple arm64-apple-ios11 -fobjc-arc -fblocks -fobjc-runtime=ios-11.0 -include-pch %t -emit-llvm -o - -DUSESTRUCT %s | FileCheck %s
|
|
150
|
5
|
|
|
6 #ifndef HEADER
|
|
|
7 #define HEADER
|
|
|
8
|
|
|
9 typedef void (^BlockTy)(void);
|
|
|
10
|
|
|
11 typedef struct {
|
|
|
12 int a[4];
|
|
|
13 } Trivial;
|
|
|
14
|
|
|
15 typedef struct {
|
|
|
16 Trivial f0;
|
|
|
17 id f1;
|
|
|
18 } Strong;
|
|
|
19
|
|
|
20 typedef struct {
|
|
|
21 int i;
|
|
|
22 id f1;
|
|
|
23 } StrongSmall;
|
|
|
24
|
|
|
25 typedef struct {
|
|
|
26 Strong f0;
|
|
|
27 id f1;
|
|
|
28 double d;
|
|
|
29 } StrongOuter;
|
|
|
30
|
|
|
31 typedef struct {
|
|
|
32 id f0;
|
|
|
33 Strong f1;
|
|
|
34 } StrongOuter2;
|
|
|
35
|
|
|
36 typedef struct {
|
|
|
37 int f0;
|
|
|
38 volatile id f1;
|
|
|
39 } StrongVolatile;
|
|
|
40
|
|
|
41 typedef struct {
|
|
|
42 BlockTy f0;
|
|
|
43 } StrongBlock;
|
|
|
44
|
|
|
45 typedef struct {
|
|
|
46 int i;
|
|
|
47 id f0[2][2];
|
|
|
48 } IDArray;
|
|
|
49
|
|
|
50 typedef struct {
|
|
|
51 double d;
|
|
|
52 Strong f0[2][2];
|
|
|
53 } StructArray;
|
|
|
54
|
|
|
55 typedef struct {
|
|
|
56 id f0;
|
|
|
57 int i : 9;
|
|
|
58 } Bitfield0;
|
|
|
59
|
|
|
60 typedef struct {
|
|
|
61 char c;
|
|
|
62 int i0 : 2;
|
|
|
63 int i1 : 4;
|
|
|
64 id f0;
|
|
|
65 int i2 : 31;
|
|
|
66 int i3 : 1;
|
|
|
67 id f1;
|
|
|
68 int : 0;
|
|
|
69 int a[3];
|
|
|
70 id f2;
|
|
|
71 double d;
|
|
|
72 int i4 : 1;
|
|
|
73 volatile int i5 : 2;
|
|
|
74 volatile char i6;
|
|
|
75 } Bitfield1;
|
|
|
76
|
|
|
77 typedef struct {
|
|
|
78 id x;
|
|
|
79 volatile int a[16];
|
|
|
80 } VolatileArray ;
|
|
|
81
|
|
221
|
82 typedef struct {
|
|
|
83 _Bool f0[2];
|
|
|
84 VolatileArray f1;
|
|
|
85 } StructWithBool;
|
|
|
86
|
|
150
|
87 #endif
|
|
|
88
|
|
|
89 #ifdef USESTRUCT
|
|
|
90
|
|
|
91 StrongSmall getStrongSmall(void);
|
|
|
92 StrongOuter getStrongOuter(void);
|
|
|
93 StrongOuter2 getStrongOuter2(void);
|
|
|
94 void calleeStrongSmall(StrongSmall);
|
|
|
95 void func(Strong *);
|
|
|
96
|
|
173
|
97 @interface C
|
|
|
98 - (StrongSmall)getStrongSmall;
|
|
221
|
99 - (void)m:(StrongSmall)s;
|
|
173
|
100 + (StrongSmall)getStrongSmallClass;
|
|
|
101 @end
|
|
|
102
|
|
|
103 id g0;
|
|
221
|
104 StrongSmall g1, g2;
|
|
173
|
105
|
|
252
|
106 // CHECK: %[[STRUCT_STRONGSMALL:.*]] = type { i32, ptr }
|
|
|
107 // CHECK: %[[STRUCT_STRONGOUTER:.*]] = type { %[[STRUCT_STRONG:.*]], ptr, double }
|
|
|
108 // CHECK: %[[STRUCT_STRONG]] = type { %[[STRUCT_TRIVIAL:.*]], ptr }
|
|
150
|
109 // CHECK: %[[STRUCT_TRIVIAL]] = type { [4 x i32] }
|
|
252
|
110 // CHECK: %[[STRUCT_BLOCK_BYREF_T:.*]] = type { ptr, ptr, i32, i32, ptr, ptr, ptr, %[[STRUCT_STRONGOUTER]] }
|
|
|
111 // CHECK: %[[STRUCT_STRONGBLOCK:.*]] = type { ptr }
|
|
|
112 // CHECK: %[[STRUCT_BITFIELD1:.*]] = type { i8, i8, ptr, i32, ptr, [3 x i32], ptr, double, i8, i8 }
|
|
150
|
113
|
|
221
|
114 // CHECK: define{{.*}} void @test_constructor_destructor_StrongOuter()
|
|
150
|
115 // CHECK: %[[T:.*]] = alloca %[[STRUCT_STRONGOUTER]], align 8
|
|
252
|
116 // CHECK: call void @__default_constructor_8_S_s16_s24(ptr %[[T]])
|
|
|
117 // CHECK: call void @__destructor_8_S_s16_s24(ptr %[[T]])
|
|
150
|
118 // CHECK: ret void
|
|
|
119
|
|
252
|
120 // CHECK: define linkonce_odr hidden void @__default_constructor_8_S_s16_s24(ptr noundef %[[DST:.*]])
|
|
|
121 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
122 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
123 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
124 // CHECK: call void @__default_constructor_8_s16(ptr %[[V0]])
|
|
|
125 // CHECK: %[[V2:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 24
|
|
|
126 // CHECK: call void @llvm.memset.p0.i64(ptr align 8 %[[V2]], i8 0, i64 8, i1 false)
|
|
150
|
127 // CHECK: ret void
|
|
|
128
|
|
252
|
129 // CHECK: define linkonce_odr hidden void @__default_constructor_8_s16(ptr noundef %[[DST:.*]])
|
|
|
130 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
131 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
132 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
133 // CHECK: %[[V2:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 16
|
|
|
134 // CHECK: call void @llvm.memset.p0.i64(ptr align 8 %[[V2]], i8 0, i64 8, i1 false)
|
|
150
|
135 // CHECK: ret void
|
|
|
136
|
|
252
|
137 // CHECK: define linkonce_odr hidden void @__destructor_8_S_s16_s24(ptr noundef %[[DST:.*]])
|
|
|
138 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
139 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
140 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
141 // CHECK: call void @__destructor_8_s16(ptr %[[V0]])
|
|
|
142 // CHECK: %[[V2:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 24
|
|
|
143 // CHECK: call void @llvm.objc.storeStrong(ptr %[[V2]], ptr null)
|
|
150
|
144 // CHECK: ret void
|
|
|
145
|
|
252
|
146 // CHECK: define linkonce_odr hidden void @__destructor_8_s16(ptr noundef %[[DST:.*]])
|
|
|
147 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
148 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
149 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
150 // CHECK: %[[V2:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 16
|
|
|
151 // CHECK: call void @llvm.objc.storeStrong(ptr %[[V2]], ptr null)
|
|
150
|
152 // CHECK: ret void
|
|
|
153
|
|
|
154 void test_constructor_destructor_StrongOuter(void) {
|
|
|
155 StrongOuter t;
|
|
|
156 }
|
|
|
157
|
|
252
|
158 // CHECK: define{{.*}} void @test_copy_constructor_StrongOuter(ptr noundef %[[S:.*]])
|
|
|
159 // CHECK: %[[S_ADDR:.*]] = alloca ptr, align 8
|
|
150
|
160 // CHECK: %[[T:.*]] = alloca %[[STRUCT_STRONGOUTER]], align 8
|
|
252
|
161 // CHECK: store ptr %[[S]], ptr %[[S_ADDR]], align 8
|
|
|
162 // CHECK: %[[V0:.*]] = load ptr, ptr %[[S_ADDR]], align 8
|
|
|
163 // CHECK: call void @__copy_constructor_8_8_S_t0w16_s16_s24_t32w8(ptr %[[T]], ptr %[[V0]])
|
|
|
164 // CHECK: call void @__destructor_8_S_s16_s24(ptr %[[T]])
|
|
150
|
165 // CHECK: ret void
|
|
|
166
|
|
252
|
167 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_S_t0w16_s16_s24_t32w8(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
168 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
169 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
170 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
171 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
172 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
173 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
174 // CHECK: call void @__copy_constructor_8_8_t0w16_s16(ptr %[[V0]], ptr %[[V1]])
|
|
|
175 // CHECK: %[[V3:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 24
|
|
|
176 // CHECK: %[[V6:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 24
|
|
|
177 // CHECK: %[[V8:.*]] = load ptr, ptr %[[V6]], align 8
|
|
|
178 // CHECK: %[[V9:.*]] = call ptr @llvm.objc.retain(ptr %[[V8]])
|
|
|
179 // CHECK: store ptr %[[V9]], ptr %[[V3]], align 8
|
|
|
180 // CHECK: %[[V11:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 32
|
|
|
181 // CHECK: %[[V14:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 32
|
|
|
182 // CHECK: %[[V18:.*]] = load i64, ptr %[[V14]], align 8
|
|
|
183 // CHECK: store i64 %[[V18]], ptr %[[V11]], align 8
|
|
150
|
184 // CHECK: ret void
|
|
|
185
|
|
252
|
186 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w16_s16(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
187 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
188 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
189 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
190 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
191 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
192 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
193 // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %[[V0]], ptr align 8 %[[V1]], i64 16, i1 false)
|
|
|
194 // CHECK: %[[V5:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 16
|
|
|
195 // CHECK: %[[V8:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 16
|
|
|
196 // CHECK: %[[V10:.*]] = load ptr, ptr %[[V8]], align 8
|
|
|
197 // CHECK: %[[V11:.*]] = call ptr @llvm.objc.retain(ptr %[[V10]])
|
|
|
198 // CHECK: store ptr %[[V11]], ptr %[[V5]], align 8
|
|
150
|
199 // CHECK: ret void
|
|
|
200
|
|
|
201 void test_copy_constructor_StrongOuter(StrongOuter *s) {
|
|
|
202 StrongOuter t = *s;
|
|
|
203 }
|
|
|
204
|
|
252
|
205 /// CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_S_t0w16_s16_s24_t32w8(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
206 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
207 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
208 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
209 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
210 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
211 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
212 // CHECK: %[[V3:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 24
|
|
|
213 // CHECK: %[[V6:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 24
|
|
|
214 // CHECK: %[[V8:.*]] = load ptr, ptr %[[V6]], align 8
|
|
|
215 // CHECK: call void @llvm.objc.storeStrong(ptr %[[V3]], ptr %[[V8]])
|
|
150
|
216
|
|
|
217 void test_copy_assignment_StrongOuter(StrongOuter *d, StrongOuter *s) {
|
|
|
218 *d = *s;
|
|
|
219 }
|
|
|
220
|
|
221
|
221 // CHECK: define{{.*}} void @test_move_constructor_StrongOuter()
|
|
252
|
222 // CHECK: %[[T1:.*]] = getelementptr inbounds %[[STRUCT_BLOCK_BYREF_T]], ptr %{{.*}}, i32 0, i32 7
|
|
|
223 // CHECK: call void @__default_constructor_8_S_s16_s24(ptr %[[T1]])
|
|
|
224 // CHECK: %[[T2:.*]] = getelementptr inbounds %[[STRUCT_BLOCK_BYREF_T]], ptr %{{.*}}, i32 0, i32 7
|
|
|
225 // CHECK: call void @__destructor_8_S_s16_s24(ptr %[[T2]])
|
|
150
|
226
|
|
252
|
227 // CHECK: define internal void @__Block_byref_object_copy_(ptr noundef %0, ptr noundef %1)
|
|
150
|
228 // CHECK: call void @__move_constructor_8_8_S_t0w16_s16_s24_t32w8(
|
|
|
229
|
|
252
|
230 // CHECK: define linkonce_odr hidden void @__move_constructor_8_8_S_t0w16_s16_s24_t32w8(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
231 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
232 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
233 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
234 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
235 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
236 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
237 // CHECK: call void @__move_constructor_8_8_t0w16_s16(ptr %[[V0]], ptr %[[V1]])
|
|
|
238 // CHECK: %[[V3:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 24
|
|
|
239 // CHECK: %[[V6:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 24
|
|
|
240 // CHECK: %[[V8:.*]] = load ptr, ptr %[[V6]], align 8
|
|
|
241 // CHECK: store ptr null, ptr %[[V6]], align 8
|
|
|
242 // CHECK: store ptr %[[V8]], ptr %[[V3]], align 8
|
|
150
|
243
|
|
252
|
244 // CHECK: define internal void @__Block_byref_object_dispose_(ptr noundef %0)
|
|
150
|
245 // CHECK: call void @__destructor_8_S_s16_s24(
|
|
|
246
|
|
|
247 void test_move_constructor_StrongOuter(void) {
|
|
|
248 __block StrongOuter t;
|
|
|
249 BlockTy b = ^{ (void)t; };
|
|
|
250 }
|
|
|
251
|
|
252
|
252 // CHECK: define linkonce_odr hidden void @__move_assignment_8_8_S_t0w16_s16_s24_t32w8(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
253 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
254 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
255 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
256 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
257 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
258 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
259 // CHECK: call void @__move_assignment_8_8_t0w16_s16(ptr %[[V0]], ptr %[[V1]])
|
|
|
260 // CHECK: %[[V3:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 24
|
|
|
261 // CHECK: %[[V6:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 24
|
|
|
262 // CHECK: %[[V8:.*]] = load ptr, ptr %[[V6]], align 8
|
|
|
263 // CHECK: store ptr null, ptr %[[V6]], align 8
|
|
|
264 // CHECK: %[[V9:.*]] = load ptr, ptr %[[V3]], align 8
|
|
|
265 // CHECK: store ptr %[[V8]], ptr %[[V3]], align 8
|
|
|
266 // CHECK: call void @llvm.objc.release(ptr %[[V9]])
|
|
150
|
267
|
|
|
268 void test_move_assignment_StrongOuter(StrongOuter *p) {
|
|
|
269 *p = getStrongOuter();
|
|
|
270 }
|
|
|
271
|
|
252
|
272 // CHECK: define linkonce_odr hidden void @__default_constructor_8_s0_S_s24(ptr noundef %[[DST:.*]])
|
|
|
273 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
274 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
275 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
276 // CHECK: call void @llvm.memset.p0.i64(ptr align 8 %[[V0]], i8 0, i64 8, i1 false)
|
|
|
277 // CHECK: %[[V3:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 8
|
|
|
278 // CHECK: call void @__default_constructor_8_s16(ptr %[[V3]])
|
|
150
|
279
|
|
252
|
280 // CHECK: define linkonce_odr hidden void @__destructor_8_s0_S_s24(ptr noundef %[[DST:.*]])
|
|
|
281 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
282 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
283 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
284 // CHECK: call void @llvm.objc.storeStrong(ptr %[[V0]], ptr null)
|
|
|
285 // CHECK: %[[V2:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 8
|
|
|
286 // CHECK: call void @__destructor_8_s16(ptr %[[V2]])
|
|
150
|
287
|
|
|
288 void test_constructor_destructor_StrongOuter2(void) {
|
|
|
289 StrongOuter2 t;
|
|
|
290 }
|
|
|
291
|
|
252
|
292 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_s0_S_t8w16_s24(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
293 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
294 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
295 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
296 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
297 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
298 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
299 // CHECK: %[[V2:.*]] = load ptr, ptr %[[V1]], align 8
|
|
|
300 // CHECK: %[[V3:.*]] = call ptr @llvm.objc.retain(ptr %[[V2]])
|
|
|
301 // CHECK: store ptr %[[V3]], ptr %[[V0]], align 8
|
|
|
302 // CHECK: %[[V5:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 8
|
|
|
303 // CHECK: %[[V8:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 8
|
|
|
304 // CHECK: call void @__copy_constructor_8_8_t0w16_s16(ptr %[[V5]], ptr %[[V8]])
|
|
150
|
305
|
|
|
306 void test_copy_constructor_StrongOuter2(StrongOuter2 *s) {
|
|
|
307 StrongOuter2 t = *s;
|
|
|
308 }
|
|
|
309
|
|
252
|
310 // CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_s0_S_t8w16_s24(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
311 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
312 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
313 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
314 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
315 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
316 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
317 // CHECK: %[[V2:.*]] = load ptr, ptr %[[V1]], align 8
|
|
|
318 // CHECK: call void @llvm.objc.storeStrong(ptr %[[V0]], ptr %[[V2]])
|
|
|
319 // CHECK: %[[V4:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 8
|
|
|
320 // CHECK: %[[V7:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 8
|
|
|
321 // CHECK: call void @__copy_assignment_8_8_t0w16_s16(ptr %[[V4]], ptr %[[V7]])
|
|
150
|
322
|
|
|
323 void test_copy_assignment_StrongOuter2(StrongOuter2 *d, StrongOuter2 *s) {
|
|
|
324 *d = *s;
|
|
|
325 }
|
|
|
326
|
|
252
|
327 // CHECK: define linkonce_odr hidden void @__move_constructor_8_8_s0_S_t8w16_s24(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
328 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
329 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
330 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
331 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
332 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
333 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
334 // CHECK: %[[V2:.*]] = load ptr, ptr %[[V1]], align 8
|
|
|
335 // CHECK: store ptr null, ptr %[[V1]], align 8
|
|
|
336 // CHECK: store ptr %[[V2]], ptr %[[V0]], align 8
|
|
|
337 // CHECK: %[[V4:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 8
|
|
|
338 // CHECK: %[[V7:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 8
|
|
|
339 // CHECK: call void @__move_constructor_8_8_t0w16_s16(ptr %[[V4]], ptr %[[V7]])
|
|
150
|
340
|
|
|
341 void test_move_constructor_StrongOuter2(void) {
|
|
|
342 __block StrongOuter2 t;
|
|
|
343 BlockTy b = ^{ (void)t; };
|
|
|
344 }
|
|
|
345
|
|
252
|
346 // CHECK: define linkonce_odr hidden void @__move_assignment_8_8_s0_S_t8w16_s24(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
347 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
348 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
349 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
350 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
351 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
352 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
353 // CHECK: %[[V2:.*]] = load ptr, ptr %[[V1]], align 8
|
|
|
354 // CHECK: store ptr null, ptr %[[V1]], align 8
|
|
|
355 // CHECK: %[[V3:.*]] = load ptr, ptr %[[V0]], align 8
|
|
|
356 // CHECK: store ptr %[[V2]], ptr %[[V0]], align 8
|
|
|
357 // CHECK: call void @llvm.objc.release(ptr %[[V3]])
|
|
|
358 // CHECK: %[[V5:.*]] = getelementptr inbounds i8, ptr %[[V0]], i64 8
|
|
|
359 // CHECK: %[[V8:.*]] = getelementptr inbounds i8, ptr %[[V1]], i64 8
|
|
|
360 // CHECK: call void @__move_assignment_8_8_t0w16_s16(ptr %[[V5]], ptr %[[V8]])
|
|
150
|
361
|
|
|
362 void test_move_assignment_StrongOuter2(StrongOuter2 *p) {
|
|
|
363 *p = getStrongOuter2();
|
|
|
364 }
|
|
|
365
|
|
221
|
366 // CHECK: define{{.*}} void @test_parameter_StrongSmall([2 x i64] %[[A_COERCE:.*]])
|
|
150
|
367 // CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
252
|
368 // CHECK: store [2 x i64] %[[A_COERCE]], ptr %[[A]], align 8
|
|
|
369 // CHECK: call void @__destructor_8_s8(ptr %[[A]])
|
|
150
|
370 // CHECK: ret void
|
|
|
371
|
|
|
372 void test_parameter_StrongSmall(StrongSmall a) {
|
|
|
373 }
|
|
|
374
|
|
221
|
375 // CHECK: define{{.*}} void @test_argument_StrongSmall([2 x i64] %[[A_COERCE:.*]])
|
|
150
|
376 // CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
377 // CHECK: %[[TEMP_LVALUE:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
252
|
378 // CHECK: store [2 x i64] %[[A_COERCE]], ptr %[[A]], align 8
|
|
|
379 // CHECK: call void @__copy_constructor_8_8_t0w4_s8(ptr %[[TEMP_LVALUE]], ptr %[[A]])
|
|
|
380 // CHECK: %[[V4:.*]] = load [2 x i64], ptr %[[TEMP_LVALUE]], align 8
|
|
150
|
381 // CHECK: call void @calleeStrongSmall([2 x i64] %[[V4]])
|
|
252
|
382 // CHECK: call void @__destructor_8_s8(ptr %[[A]])
|
|
150
|
383 // CHECK: ret void
|
|
|
384
|
|
|
385 void test_argument_StrongSmall(StrongSmall a) {
|
|
|
386 calleeStrongSmall(a);
|
|
|
387 }
|
|
|
388
|
|
221
|
389 // CHECK: define{{.*}} [2 x i64] @test_return_StrongSmall([2 x i64] %[[A_COERCE:.*]])
|
|
150
|
390 // CHECK: %[[RETVAL:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
391 // CHECK: %[[A:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
252
|
392 // CHECK: store [2 x i64] %[[A_COERCE]], ptr %[[A]], align 8
|
|
|
393 // CHECK: call void @__copy_constructor_8_8_t0w4_s8(ptr %[[RETVAL]], ptr %[[A]])
|
|
|
394 // CHECK: call void @__destructor_8_s8(ptr %[[A]])
|
|
|
395 // CHECK: %[[V5:.*]] = load [2 x i64], ptr %[[RETVAL]], align 8
|
|
150
|
396 // CHECK: ret [2 x i64] %[[V5]]
|
|
|
397
|
|
|
398 StrongSmall test_return_StrongSmall(StrongSmall a) {
|
|
|
399 return a;
|
|
|
400 }
|
|
|
401
|
|
221
|
402 // CHECK: define{{.*}} void @test_destructor_ignored_result()
|
|
150
|
403 // CHECK: %[[COERCE:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
404 // CHECK: %[[CALL:.*]] = call [2 x i64] @getStrongSmall()
|
|
252
|
405 // CHECK: store [2 x i64] %[[CALL]], ptr %[[COERCE]], align 8
|
|
|
406 // CHECK: call void @__destructor_8_s8(ptr %[[COERCE]])
|
|
150
|
407 // CHECK: ret void
|
|
|
408
|
|
|
409 void test_destructor_ignored_result(void) {
|
|
|
410 getStrongSmall();
|
|
|
411 }
|
|
|
412
|
|
252
|
413 // CHECK: define{{.*}} void @test_destructor_ignored_result2(ptr noundef %[[C:.*]])
|
|
173
|
414 // CHECK: %[[TMP:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
415 // CHECK: %[[CALL:.*]] = call [2 x i64]{{.*}}@objc_msgSend
|
|
252
|
416 // CHECK: store [2 x i64] %[[CALL]], ptr %[[TMP]], align 8
|
|
|
417 // CHECK: call void @__destructor_8_s8(ptr %[[TMP]])
|
|
173
|
418
|
|
|
419 void test_destructor_ignored_result2(C *c) {
|
|
|
420 [c getStrongSmall];
|
|
|
421 }
|
|
|
422
|
|
221
|
423 // CHECK: define{{.*}} void @test_copy_constructor_StrongBlock(
|
|
150
|
424 // CHECK: call void @__copy_constructor_8_8_sb0(
|
|
|
425 // CHECK: call void @__destructor_8_sb0(
|
|
|
426 // CHECK: ret void
|
|
|
427
|
|
252
|
428 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_sb0(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
429 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
430 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
431 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
432 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
433 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
434 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
435 // CHECK: %[[V2:.*]] = load ptr, ptr %[[V1]], align 8
|
|
|
436 // CHECK: %[[V3:.*]] = call ptr @llvm.objc.retainBlock(ptr %[[V2]])
|
|
|
437 // CHECK: store ptr %[[V3]], ptr %[[V0]], align 8
|
|
150
|
438 // CHECK: ret void
|
|
|
439
|
|
|
440 void test_copy_constructor_StrongBlock(StrongBlock *s) {
|
|
|
441 StrongBlock t = *s;
|
|
|
442 }
|
|
|
443
|
|
252
|
444 // CHECK: define{{.*}} void @test_copy_assignment_StrongBlock(ptr noundef %[[D:.*]], ptr noundef %[[S:.*]])
|
|
150
|
445 // CHECK: call void @__copy_assignment_8_8_sb0(
|
|
|
446
|
|
252
|
447 // CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_sb0(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
|
448 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
449 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
450 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
451 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
452 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
453 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
454 // CHECK: %[[V2:.*]] = load ptr, ptr %[[V1]], align 8
|
|
|
455 // CHECK: %[[V3:.*]] = call ptr @llvm.objc.retainBlock(ptr %[[V2]])
|
|
|
456 // CHECK: %[[V4:.*]] = load ptr, ptr %[[V0]], align 8
|
|
|
457 // CHECK: store ptr %[[V3]], ptr %[[V0]], align 8
|
|
|
458 // CHECK: call void @llvm.objc.release(ptr %[[V4]])
|
|
150
|
459 // CHECK: ret void
|
|
|
460
|
|
|
461 void test_copy_assignment_StrongBlock(StrongBlock *d, StrongBlock *s) {
|
|
|
462 *d = *s;
|
|
|
463 }
|
|
|
464
|
|
221
|
465 // CHECK-LABEL: define{{.*}} void @test_copy_assignment_StructWithBool(
|
|
|
466 // CHECK: call void @__copy_assignment_8_8_AB0s1n2_tv0w8_AE_S_sv8_AB16s4n16_tv128w32_AE(
|
|
|
467
|
|
|
468 // CHECK-LABEL: define linkonce_odr hidden void @__copy_assignment_8_8_AB0s1n2_tv0w8_AE_S_sv8_AB16s4n16_tv128w32_AE(
|
|
252
|
469 // CHECK: %[[ADDR_CUR:.*]] = phi ptr
|
|
|
470 // CHECK: %[[ADDR_CUR1:.*]] = phi ptr
|
|
221
|
471
|
|
252
|
472 // CHECK: %[[V6:.*]] = load volatile i8, ptr %[[ADDR_CUR1]], align 1
|
|
221
|
473 // CHECK: %[[TOBOOL:.*]] = trunc i8 %[[V6]] to i1
|
|
|
474 // CHECK: %[[FROMBOOL:.*]] = zext i1 %[[TOBOOL]] to i8
|
|
252
|
475 // CHECK: store volatile i8 %[[FROMBOOL]], ptr %[[ADDR_CUR]], align 1
|
|
221
|
476
|
|
|
477 void test_copy_assignment_StructWithBool(StructWithBool *d, StructWithBool *s) {
|
|
|
478 *d = *s;
|
|
|
479 }
|
|
|
480
|
|
|
481 // CHECK: define{{.*}} void @test_copy_constructor_StrongVolatile0(
|
|
150
|
482 // CHECK: call void @__copy_constructor_8_8_t0w4_sv8(
|
|
173
|
483 // CHECK-NOT: call
|
|
150
|
484 // CHECK: call void @__destructor_8_sv8(
|
|
173
|
485 // CHECK-NOT: call
|
|
150
|
486
|
|
|
487 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w4_sv8(
|
|
252
|
488 // CHECK: %[[V8:.*]] = load volatile ptr, ptr %{{.*}}, align 8
|
|
|
489 // CHECK: %[[V9:.*]] = call ptr @llvm.objc.retain(ptr %[[V8]])
|
|
|
490 // CHECK: store volatile ptr %[[V9]], ptr %{{.*}}, align 8
|
|
150
|
491
|
|
|
492 void test_copy_constructor_StrongVolatile0(StrongVolatile *s) {
|
|
|
493 StrongVolatile t = *s;
|
|
|
494 }
|
|
|
495
|
|
221
|
496 // CHECK: define{{.*}} void @test_copy_constructor_StrongVolatile1(
|
|
150
|
497 // CHECK: call void @__copy_constructor_8_8_tv0w128_sv16(
|
|
|
498
|
|
|
499 void test_copy_constructor_StrongVolatile1(Strong *s) {
|
|
|
500 volatile Strong t = *s;
|
|
|
501 }
|
|
|
502
|
|
221
|
503 // CHECK: define{{.*}} void @test_block_capture_Strong()
|
|
150
|
504 // CHECK: call void @__default_constructor_8_s16(
|
|
|
505 // CHECK: call void @__copy_constructor_8_8_t0w16_s16(
|
|
|
506 // CHECK: call void @__destructor_8_s16(
|
|
|
507 // CHECK: call void @__destructor_8_s16(
|
|
|
508 // CHECK: ret void
|
|
|
509
|
|
252
|
510 // CHECK: define linkonce_odr hidden void @__copy_helper_block_8_32n13_8_8_t0w16_s16(ptr noundef %0, ptr noundef %1)
|
|
150
|
511 // CHECK: call void @__copy_constructor_8_8_t0w16_s16(
|
|
|
512 // CHECK: ret void
|
|
|
513
|
|
|
514 // CHECK: define linkonce_odr hidden void @__destroy_helper_block_8_32n5_8_s16(
|
|
|
515 // CHECK: call void @__destructor_8_s16(
|
|
|
516 // CHECK: ret void
|
|
|
517
|
|
|
518 void test_block_capture_Strong(void) {
|
|
|
519 Strong t;
|
|
236
|
520 BlockTy b = ^(void){ (void)t; };
|
|
150
|
521 }
|
|
|
522
|
|
236
|
523 // CHECK: define{{.*}} void @test_variable_length_array(i32 noundef %[[N:.*]])
|
|
150
|
524 // CHECK: %[[N_ADDR:.*]] = alloca i32, align 4
|
|
252
|
525 // CHECK: store i32 %[[N]], ptr %[[N_ADDR]], align 4
|
|
|
526 // CHECK: %[[V0:.*]] = load i32, ptr %[[N_ADDR]], align 4
|
|
150
|
527 // CHECK: %[[V1:.*]] = zext i32 %[[V0]] to i64
|
|
|
528 // CHECK: %[[VLA:.*]] = alloca %[[STRUCT_STRONG]], i64 %[[V1]], align 8
|
|
|
529 // CHECK: %[[V4:.*]] = mul nuw i64 24, %[[V1]]
|
|
252
|
530 // CHECK: %[[V6:.*]] = getelementptr inbounds i8, ptr %[[VLA]], i64 %[[V4]]
|
|
150
|
531 // CHECK: br label
|
|
|
532
|
|
252
|
533 // CHECK: %[[DSTADDR_CUR:.*]] = phi ptr [ %[[VLA]], {{.*}} ], [ %[[V7:.*]], {{.*}} ]
|
|
|
534 // CHECK: %[[DONE:.*]] = icmp eq ptr %[[DSTADDR_CUR]], %[[V6]]
|
|
150
|
535 // CHECK: br i1 %[[DONE]], label
|
|
|
536
|
|
252
|
537 // CHECK: call void @__default_constructor_8_s16(ptr %[[DSTADDR_CUR]])
|
|
|
538 // CHECK: %[[V9:.*]] = getelementptr inbounds i8, ptr %[[DSTADDR_CUR]], i64 24
|
|
150
|
539 // CHECK: br label
|
|
|
540
|
|
252
|
541 // CHECK: call void @func(ptr noundef %[[VLA]])
|
|
|
542 // CHECK: %[[V10:.*]] = getelementptr inbounds %[[STRUCT_STRONG]], ptr %[[VLA]], i64 %[[V1]]
|
|
|
543 // CHECK: %[[ARRAYDESTROY_ISEMPTY:.*]] = icmp eq ptr %[[VLA]], %[[V10]]
|
|
150
|
544 // CHECK: br i1 %[[ARRAYDESTROY_ISEMPTY]], label
|
|
|
545
|
|
252
|
546 // CHECK: %[[ARRAYDESTROY_ELEMENTPAST:.*]] = phi ptr [ %[[V10]], {{.*}} ], [ %[[ARRAYDESTROY_ELEMENT:.*]], {{.*}} ]
|
|
|
547 // CHECK: %[[ARRAYDESTROY_ELEMENT]] = getelementptr inbounds %[[STRUCT_STRONG]], ptr %[[ARRAYDESTROY_ELEMENTPAST]], i64 -1
|
|
|
548 // CHECK: call void @__destructor_8_s16(ptr %[[ARRAYDESTROY_ELEMENT]])
|
|
|
549 // CHECK: %[[ARRAYDESTROY_DONE:.*]] = icmp eq ptr %[[ARRAYDESTROY_ELEMENT]], %[[VLA]]
|
|
150
|
550 // CHECK: br i1 %[[ARRAYDESTROY_DONE]], label
|
|
|
551
|
|
|
552 // CHECK: ret void
|
|
|
553
|
|
|
554 void test_variable_length_array(int n) {
|
|
|
555 Strong a[n];
|
|
|
556 func(a);
|
|
|
557 }
|
|
|
558
|
|
|
559 // CHECK: define linkonce_odr hidden void @__default_constructor_8_AB8s8n4_s8_AE(
|
|
252
|
560 // CHECK: call void @llvm.memset.p0.i64(ptr align 8 %{{.*}}, i8 0, i64 32, i1 false)
|
|
150
|
561 void test_constructor_destructor_IDArray(void) {
|
|
|
562 IDArray t;
|
|
|
563 }
|
|
|
564
|
|
|
565 // CHECK: define linkonce_odr hidden void @__default_constructor_8_AB8s24n4_S_s24_AE(
|
|
|
566 void test_constructor_destructor_StructArray(void) {
|
|
|
567 StructArray t;
|
|
|
568 }
|
|
|
569
|
|
|
570 // Test that StructArray's field 'd' is copied before entering the loop.
|
|
|
571
|
|
252
|
572 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w8_AB8s24n4_S_t8w16_s24_AE(ptr noundef %[[DST:.*]], ptr noundef %[[SRC:.*]])
|
|
150
|
573 // CHECK: entry:
|
|
252
|
574 // CHECK: %[[DST_ADDR:.*]] = alloca ptr, align 8
|
|
|
575 // CHECK: %[[SRC_ADDR:.*]] = alloca ptr, align 8
|
|
|
576 // CHECK: store ptr %[[DST]], ptr %[[DST_ADDR]], align 8
|
|
|
577 // CHECK: store ptr %[[SRC]], ptr %[[SRC_ADDR]], align 8
|
|
|
578 // CHECK: %[[V0:.*]] = load ptr, ptr %[[DST_ADDR]], align 8
|
|
|
579 // CHECK: %[[V1:.*]] = load ptr, ptr %[[SRC_ADDR]], align 8
|
|
|
580 // CHECK: %[[V4:.*]] = load i64, ptr %[[V1]], align 8
|
|
|
581 // CHECK: store i64 %[[V4]], ptr %[[V0]], align 8
|
|
150
|
582
|
|
252
|
583 // CHECK: phi ptr
|
|
|
584 // CHECK: phi ptr
|
|
150
|
585
|
|
252
|
586 // CHECK: phi ptr
|
|
|
587 // CHECK: phi ptr
|
|
150
|
588
|
|
252
|
589 // CHECK-NOT: load i64, ptr %
|
|
150
|
590 // CHECK-NOT: store i64 %
|
|
|
591 // CHECK: call void @__copy_constructor_8_8_t0w16_s16(
|
|
|
592
|
|
|
593 void test_copy_constructor_StructArray(StructArray a) {
|
|
|
594 StructArray t = a;
|
|
|
595 }
|
|
|
596
|
|
|
597 // Check that IRGen copies the 9-bit bitfield emitting i16 load and store.
|
|
|
598
|
|
221
|
599 // CHECK: define{{.*}} void @test_copy_constructor_Bitfield0(
|
|
150
|
600
|
|
|
601 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_s0_t8w2(
|
|
252
|
602 // CHECK: %[[V5:.*]] = getelementptr inbounds i8, ptr %{{.*}}, i64 8
|
|
|
603 // CHECK: %[[V8:.*]] = getelementptr inbounds i8, ptr %{{.*}}, i64 8
|
|
|
604 // CHECK: %[[V12:.*]] = load i16, ptr %[[V8]], align 8
|
|
|
605 // CHECK: store i16 %[[V12]], ptr %[[V5]], align 8
|
|
150
|
606 // CHECK: ret void
|
|
|
607
|
|
|
608 void test_copy_constructor_Bitfield0(Bitfield0 *a) {
|
|
|
609 Bitfield0 t = *a;
|
|
|
610 }
|
|
|
611
|
|
|
612 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_t0w2_s8_t16w4_s24_t32w12_s48_t56w9_tv513w2_tv520w8
|
|
252
|
613 // CHECK: %[[V4:.*]] = load i16, ptr %{{.*}}, align 8
|
|
|
614 // CHECK: store i16 %[[V4]], ptr %{{.*}}, align 8
|
|
|
615 // CHECK: %[[V21:.*]] = load i32, ptr %{{.*}}, align 8
|
|
|
616 // CHECK: store i32 %[[V21]], ptr %{{.*}}, align 8
|
|
|
617 // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %{{.*}}, ptr align 8 %{{.*}}, i64 12, i1 false)
|
|
|
618 // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %{{.*}}, ptr align 8 %{{.*}}, i64 9, i1 false)
|
|
|
619 // CHECK: %[[I5:.*]] = getelementptr inbounds %[[STRUCT_BITFIELD1]], ptr %[[V0:.*]], i32 0, i32 8
|
|
|
620 // CHECK: %[[I51:.*]] = getelementptr inbounds %[[STRUCT_BITFIELD1]], ptr %[[V1:.*]], i32 0, i32 8
|
|
|
621 // CHECK: %[[BF_LOAD:.*]] = load volatile i8, ptr %[[I51]], align 8
|
|
150
|
622 // CHECK: %[[BF_SHL:.*]] = shl i8 %[[BF_LOAD]], 5
|
|
|
623 // CHECK: %[[BF_ASHR:.*]] = ashr i8 %[[BF_SHL]], 6
|
|
|
624 // CHECK: %[[BF_CAST:.*]] = sext i8 %[[BF_ASHR]] to i32
|
|
|
625 // CHECK: %[[V56:.*]] = trunc i32 %[[BF_CAST]] to i8
|
|
252
|
626 // CHECK: %[[BF_LOAD2:.*]] = load volatile i8, ptr %[[I5]], align 8
|
|
150
|
627 // CHECK: %[[BF_VALUE:.*]] = and i8 %[[V56]], 3
|
|
|
628 // CHECK: %[[BF_SHL3:.*]] = shl i8 %[[BF_VALUE]], 1
|
|
|
629 // CHECK: %[[BF_CLEAR:.*]] = and i8 %[[BF_LOAD2]], -7
|
|
|
630 // CHECK: %[[BF_SET:.*]] = or i8 %[[BF_CLEAR]], %[[BF_SHL3]]
|
|
252
|
631 // CHECK: store volatile i8 %[[BF_SET]], ptr %[[I5]], align 8
|
|
|
632 // CHECK: %[[I6:.*]] = getelementptr inbounds %[[STRUCT_BITFIELD1]], ptr %[[V0]], i32 0, i32 9
|
|
|
633 // CHECK: %[[I64:.*]] = getelementptr inbounds %[[STRUCT_BITFIELD1]], ptr %[[V1]], i32 0, i32 9
|
|
|
634 // CHECK: %[[V59:.*]] = load volatile i8, ptr %[[I64]], align 1
|
|
|
635 // CHECK: store volatile i8 %[[V59]], ptr %[[I6]], align 1
|
|
150
|
636
|
|
|
637 void test_copy_constructor_Bitfield1(Bitfield1 *a) {
|
|
|
638 Bitfield1 t = *a;
|
|
|
639 }
|
|
|
640
|
|
221
|
641 // CHECK: define{{.*}} void @test_copy_constructor_VolatileArray(
|
|
150
|
642 // CHECK: call void @__copy_constructor_8_8_s0_AB8s4n16_tv64w32_AE(
|
|
|
643
|
|
|
644 // CHECK: define linkonce_odr hidden void @__copy_constructor_8_8_s0_AB8s4n16_tv64w32_AE(
|
|
252
|
645 // CHECK: %[[ADDR_CUR:.*]] = phi ptr
|
|
|
646 // CHECK: %[[ADDR_CUR1:.*]] = phi ptr
|
|
|
647 // CHECK: %[[V14:.*]] = load volatile i32, ptr %[[ADDR_CUR1]], align 4
|
|
|
648 // CHECK: store volatile i32 %[[V14]], ptr %[[ADDR_CUR]], align 4
|
|
150
|
649
|
|
|
650 void test_copy_constructor_VolatileArray(VolatileArray *a) {
|
|
|
651 VolatileArray t = *a;
|
|
|
652 }
|
|
|
653
|
|
221
|
654 // CHECK: define{{.*}} void @test_compound_literal0(
|
|
252
|
655 // CHECK: %[[P:.*]] = alloca ptr, align 8
|
|
173
|
656 // CHECK: %[[_COMPOUNDLITERAL:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
657 // CHECK: %[[CLEANUP_COND:.*]] = alloca i1, align 1
|
|
|
658 // CHECK: %[[_COMPOUNDLITERAL1:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
659 // CHECK: %[[CLEANUP_COND4:.*]] = alloca i1, align 1
|
|
|
660
|
|
252
|
661 // CHECK: %[[I:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[_COMPOUNDLITERAL]], i32 0, i32 0
|
|
|
662 // CHECK: store i32 1, ptr %[[I]], align 8
|
|
|
663 // CHECK: %[[F1:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[_COMPOUNDLITERAL]], i32 0, i32 1
|
|
|
664 // CHECK: store ptr null, ptr %[[F1]], align 8
|
|
|
665 // CHECK: store i1 true, ptr %[[CLEANUP_COND]], align 1
|
|
173
|
666
|
|
252
|
667 // CHECK: %[[I2:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[_COMPOUNDLITERAL1]], i32 0, i32 0
|
|
|
668 // CHECK: store i32 2, ptr %[[I2]], align 8
|
|
|
669 // CHECK: %[[F13:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[_COMPOUNDLITERAL1]], i32 0, i32 1
|
|
|
670 // CHECK: store ptr null, ptr %[[F13]], align 8
|
|
|
671 // CHECK: store i1 true, ptr %[[CLEANUP_COND4]], align 1
|
|
173
|
672
|
|
252
|
673 // CHECK: %[[COND:.*]] = phi ptr [ %[[_COMPOUNDLITERAL]], %{{.*}} ], [ %[[_COMPOUNDLITERAL1]], %{{.*}} ]
|
|
|
674 // CHECK: store ptr %[[COND]], ptr %[[P]], align 8
|
|
173
|
675 // CHECK: call void @func(
|
|
|
676
|
|
252
|
677 // CHECK: call void @__destructor_8_s8(ptr %[[_COMPOUNDLITERAL1]])
|
|
173
|
678
|
|
252
|
679 // CHECK: call void @__destructor_8_s8(ptr %[[_COMPOUNDLITERAL]])
|
|
173
|
680
|
|
|
681 void test_compound_literal0(int c) {
|
|
|
682 StrongSmall *p = c ? &(StrongSmall){ 1, 0 } : &(StrongSmall){ 2, 0 };
|
|
|
683 func(0);
|
|
|
684 }
|
|
|
685
|
|
|
686 // Check that there is only one destructor call, which destructs 't'.
|
|
|
687
|
|
221
|
688 // CHECK: define{{.*}} void @test_compound_literal1(
|
|
173
|
689 // CHECK: %[[T:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
690
|
|
252
|
691 // CHECK: %[[I:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[T]], i32 0, i32 0
|
|
|
692 // CHECK: store i32 1, ptr %[[I]], align 8
|
|
|
693 // CHECK: %[[F1:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[T]], i32 0, i32 1
|
|
|
694 // CHECK: store ptr null, ptr %[[F1]], align 8
|
|
173
|
695
|
|
252
|
696 // CHECK: %[[I1:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[T]], i32 0, i32 0
|
|
|
697 // CHECK: store i32 2, ptr %[[I1]], align 8
|
|
|
698 // CHECK: %[[F12:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[T]], i32 0, i32 1
|
|
|
699 // CHECK: store ptr null, ptr %[[F12]], align 8
|
|
173
|
700
|
|
|
701 // CHECK: call void @func(
|
|
|
702 // CHECK-NOT: call void
|
|
252
|
703 // CHECK: call void @__destructor_8_s8(ptr %[[T]])
|
|
173
|
704 // CHECK-NOT: call void
|
|
|
705
|
|
|
706 void test_compound_literal1(int c) {
|
|
|
707 StrongSmall t = c ? (StrongSmall){ 1, 0 } : (StrongSmall){ 2, 0 };
|
|
|
708 func(0);
|
|
|
709 }
|
|
|
710
|
|
221
|
711 // CHECK: define{{.*}} void @test_compound_literal2(
|
|
252
|
712 // CHECK: %[[P_ADDR:.*]] = alloca ptr, align 8
|
|
173
|
713 // CHECK: %[[_COMPOUNDLITERAL:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
714 // CHECK: %[[CLEANUP_COND:.*]] = alloca i1, align 1
|
|
|
715 // CHECK: %[[_COMPOUNDLITERAL1:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
716 // CHECK: %[[CLEANUP_COND4:.*]] = alloca i1, align 1
|
|
252
|
717 // CHECK: %[[V0:.*]] = load ptr, ptr %[[P_ADDR]], align 8
|
|
173
|
718
|
|
252
|
719 // CHECK: %[[I:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[_COMPOUNDLITERAL]], i32 0, i32 0
|
|
|
720 // CHECK: store i32 1, ptr %[[I]], align 8
|
|
|
721 // CHECK: %[[F1:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[_COMPOUNDLITERAL]], i32 0, i32 1
|
|
|
722 // CHECK: store ptr null, ptr %[[F1]], align 8
|
|
|
723 // CHECK: store i1 true, ptr %[[CLEANUP_COND]], align 1
|
|
|
724 // CHECK: call void @__copy_assignment_8_8_t0w4_s8(ptr %[[V0]], ptr %[[_COMPOUNDLITERAL]])
|
|
173
|
725
|
|
252
|
726 // CHECK: %[[I2:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[_COMPOUNDLITERAL1]], i32 0, i32 0
|
|
|
727 // CHECK: store i32 2, ptr %[[I2]], align 8
|
|
|
728 // CHECK: %[[F13:.*]] = getelementptr inbounds %[[STRUCT_STRONGSMALL]], ptr %[[_COMPOUNDLITERAL1]], i32 0, i32 1
|
|
|
729 // CHECK: store ptr null, ptr %[[F13]], align 8
|
|
|
730 // CHECK: store i1 true, ptr %[[CLEANUP_COND4]], align 1
|
|
|
731 // CHECK: call void @__copy_assignment_8_8_t0w4_s8(ptr %[[V0]], ptr %[[_COMPOUNDLITERAL1]])
|
|
173
|
732
|
|
|
733 // CHECK: call void @func(
|
|
|
734
|
|
252
|
735 // CHECK: call void @__destructor_8_s8(ptr %[[_COMPOUNDLITERAL1]])
|
|
173
|
736
|
|
252
|
737 // CHECK: call void @__destructor_8_s8(ptr %[[_COMPOUNDLITERAL]])
|
|
173
|
738
|
|
|
739 void test_compound_literal2(int c, StrongSmall *p) {
|
|
|
740 *p = c ? (StrongSmall){ 1, 0 } : (StrongSmall){ 2, 0 };
|
|
|
741 func(0);
|
|
|
742 }
|
|
|
743
|
|
221
|
744 // CHECK: define{{.*}} void @test_member_access(
|
|
173
|
745 // CHECK: %[[TMP:.*]] = alloca %[[STRUCT_STRONGSMALL]],
|
|
252
|
746 // CHECK: call void @__destructor_8_s8(ptr %[[TMP]])
|
|
173
|
747 // CHECK: call void @func(
|
|
|
748
|
|
|
749 void test_member_access(void) {
|
|
|
750 g0 = getStrongSmall().f1;
|
|
|
751 func(0);
|
|
|
752 }
|
|
|
753
|
|
252
|
754 // CHECK: define{{.*}} void @test_member_access2(ptr noundef %[[C:.*]])
|
|
173
|
755 // CHECK: %[[COERCE:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
252
|
756 // CHECK: call void @__destructor_8_s8(ptr %[[COERCE]])
|
|
173
|
757 // CHECK: call void @func(
|
|
|
758
|
|
|
759 void test_member_access2(C *c) {
|
|
|
760 g0 = [c getStrongSmall].f1;
|
|
|
761 func(0);
|
|
|
762 }
|
|
|
763
|
|
221
|
764 // CHECK: define{{.*}} void @test_member_access3(
|
|
173
|
765 // CHECK: %[[COERCE:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
252
|
766 // CHECK: call void @__destructor_8_s8(ptr %[[COERCE]])
|
|
173
|
767 // CHECK: call void @func(
|
|
|
768
|
|
|
769 void test_member_access3(void) {
|
|
|
770 g0 = [C getStrongSmallClass].f1;
|
|
|
771 func(0);
|
|
|
772 }
|
|
|
773
|
|
221
|
774 // CHECK: define{{.*}} void @test_member_access4()
|
|
173
|
775 // CHECK: %[[COERCE:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
252
|
776 // CHECK: call void @__destructor_8_s8(ptr %[[COERCE]])
|
|
173
|
777 // CHECK: call void @func(
|
|
|
778
|
|
|
779 void test_member_access4(void) {
|
|
|
780 g0 = ^{ StrongSmall s; return s; }().f1;
|
|
|
781 func(0);
|
|
|
782 }
|
|
|
783
|
|
221
|
784 // CHECK: define{{.*}} void @test_volatile_variable_reference(
|
|
173
|
785 // CHECK: %[[AGG_TMP_ENSURED:.*]] = alloca %[[STRUCT_STRONGSMALL]],
|
|
252
|
786 // CHECK: call void @__copy_constructor_8_8_tv0w32_sv8(ptr %[[AGG_TMP_ENSURED]], ptr %{{.*}})
|
|
|
787 // CHECK: call void @__destructor_8_s8(ptr %[[AGG_TMP_ENSURED]])
|
|
173
|
788 // CHECK: call void @func(
|
|
|
789
|
|
|
790 void test_volatile_variable_reference(volatile StrongSmall *a) {
|
|
|
791 (void)*a;
|
|
|
792 func(0);
|
|
|
793 }
|
|
|
794
|
|
|
795 struct ZeroBitfield {
|
|
|
796 int : 0;
|
|
|
797 id strong;
|
|
|
798 };
|
|
|
799
|
|
|
800
|
|
|
801 // CHECK: define linkonce_odr hidden void @__default_constructor_8_sv0
|
|
|
802 // CHECK: define linkonce_odr hidden void @__copy_assignment_8_8_sv0
|
|
236
|
803 void test_zero_bitfield(void) {
|
|
173
|
804 struct ZeroBitfield volatile a, b;
|
|
|
805 a = b;
|
|
|
806 }
|
|
|
807
|
|
252
|
808 // CHECK-LABEL: define{{.*}} ptr @test_conditional0(
|
|
221
|
809 // CHECK: %[[TMP:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
810
|
|
252
|
811 // CHECK: call void @__copy_constructor_8_8_t0w4_s8(ptr %[[TMP]], ptr @g2)
|
|
221
|
812
|
|
252
|
813 // CHECK: call void @__copy_constructor_8_8_t0w4_s8(ptr %[[TMP]], ptr @g1)
|
|
221
|
814
|
|
252
|
815 // CHECK: call void @__destructor_8_s8(ptr %[[TMP]])
|
|
221
|
816 // CHECK: @llvm.objc.autoreleaseReturnValue
|
|
|
817
|
|
|
818 id test_conditional0(int c) {
|
|
|
819 return (c ? g2 : g1).f1;
|
|
|
820 }
|
|
|
821
|
|
252
|
822 // CHECK-LABEL: define{{.*}} ptr @test_conditional1(
|
|
221
|
823 // CHECK-NOT: call void @__destructor
|
|
|
824
|
|
|
825 id test_conditional1(int c) {
|
|
|
826 calleeStrongSmall(c ? g2 : g1);
|
|
|
827 }
|
|
|
828
|
|
252
|
829 // CHECK-LABEL: define{{.*}} ptr @test_assignment0(
|
|
221
|
830 // CHECK: %[[TMP:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
252
|
831 // CHECK: call void @__copy_assignment_8_8_t0w4_s8(ptr @g2, ptr @g1)
|
|
|
832 // CHECK: call void @__copy_constructor_8_8_t0w4_s8(ptr %[[TMP]], ptr @g2)
|
|
|
833 // CHECK: call void @__destructor_8_s8(ptr %[[TMP]])
|
|
221
|
834
|
|
|
835 id test_assignment0(void) {
|
|
|
836 return (g2 = g1).f1;
|
|
|
837 }
|
|
|
838
|
|
252
|
839 // CHECK-LABEL: define{{.*}} ptr @test_assignment1(
|
|
221
|
840 // CHECK-NOT: call void @__destructor
|
|
|
841
|
|
|
842 id test_assignment1(void) {
|
|
|
843 calleeStrongSmall(g2 = g1);
|
|
|
844 }
|
|
|
845
|
|
|
846 // CHECK-LABEL: define{{.*}} void @test_null_reveiver(
|
|
|
847 // CHECK: %[[AGG_TMP:.*]] = alloca %[[STRUCT_STRONGSMALL]], align 8
|
|
|
848 // CHECK: br i1
|
|
|
849
|
|
252
|
850 // CHECK: %[[V8:.*]] = load [2 x i64], ptr %[[AGG_TMP]], align 8
|
|
|
851 // CHECK: call void @objc_msgSend({{.*}}, [2 x i64] %[[V8]])
|
|
221
|
852 // CHECK: br
|
|
|
853
|
|
252
|
854 // CHECK: call void @__destructor_8_s8(ptr %[[AGG_TMP]]) #4
|
|
221
|
855 // CHECK: br
|
|
|
856
|
|
|
857 void test_null_reveiver(C *c) {
|
|
|
858 [c m:getStrongSmall()];
|
|
|
859 }
|
|
|
860
|
|
150
|
861 #endif /* USESTRUCT */
|
