Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / clang / a59e4b7fca1d46afd8f315fa87fa8bf1a68df9cd / . / test / CodeGenObjC / arc-blocks.m
blob: 38675a4393342e7407f43e6001a1aa4e60a9599f [file] [log] [blame]
John McCall3382f652011-11-09 02:16:13 +0000[diff] [blame]1// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-optzns -o - %s | FileCheck %s
2
3// This shouldn't crash.
4void test0(id (^maker)(void)) {
5 maker();
6}
7
8int (^test1(int x))(void) {
9 // CHECK: define i32 ()* @test1(
10 // CHECK: [[X:%.*]] = alloca i32,
11 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
12 // CHECK-NEXT: store i32 {{%.*}}, i32* [[X]]
13 // CHECK: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to i32 ()*
14 // CHECK-NEXT: [[T1:%.*]] = bitcast i32 ()* [[T0]] to i8*
15 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]]) nounwind
16 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i32 ()*
17 // CHECK-NEXT: [[T4:%.*]] = bitcast i32 ()* [[T3]] to i8*
18 // CHECK-NEXT: [[T5:%.*]] = call i8* @objc_autoreleaseReturnValue(i8* [[T4]]) nounwind
19 // CHECK-NEXT: [[T6:%.*]] = bitcast i8* [[T5]] to i32 ()*
20 // CHECK-NEXT: ret i32 ()* [[T6]]
21 return ^{ return x; };
22}
23
24void test2(id x) {
25// CHECK: define void @test2(
26// CHECK: [[X:%.*]] = alloca i8*,
27// CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
28// CHECK-NEXT: [[PARM:%.*]] = call i8* @objc_retain(i8* {{%.*}})
29// CHECK-NEXT: store i8* [[PARM]], i8** [[X]]
30// CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
31// CHECK-NEXT: [[T0:%.*]] = load i8** [[X]],
32// CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
33// CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]],
34// CHECK-NEXT: bitcast
35// CHECK-NEXT: call void @test2_helper(
36// CHECK-NEXT: [[T0:%.*]] = load i8** [[SLOT]]
37// CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind, !clang.imprecise_release
38// CHECK-NEXT: [[T0:%.*]] = load i8** [[X]]
39// CHECK-NEXT: call void @objc_release(i8* [[T0]]) nounwind, !clang.imprecise_release
40// CHECK-NEXT: ret void
41 extern void test2_helper(id (^)(void));
42 test2_helper(^{ return x; });
43}
44
45void test3(void (^sink)(id*)) {
46 __strong id strong;
47 sink(&strong);
48
49 // CHECK: define void @test3(
50 // CHECK: [[SINK:%.*]] = alloca void (i8**)*
51 // CHECK-NEXT: [[STRONG:%.*]] = alloca i8*
52 // CHECK-NEXT: [[TEMP:%.*]] = alloca i8*
53 // CHECK-NEXT: bitcast void (i8**)* {{%.*}} to i8*
54 // CHECK-NEXT: call i8* @objc_retain(
55 // CHECK-NEXT: bitcast i8*
56 // CHECK-NEXT: store void (i8**)* {{%.*}}, void (i8**)** [[SINK]]
57 // CHECK-NEXT: store i8* null, i8** [[STRONG]]
58
59 // CHECK-NEXT: load void (i8**)** [[SINK]]
60 // CHECK-NEXT: bitcast
61 // CHECK-NEXT: getelementptr
62 // CHECK-NEXT: [[BLOCK:%.*]] = bitcast
63 // CHECK-NEXT: [[T0:%.*]] = load i8** [[STRONG]]
64 // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP]]
65 // CHECK-NEXT: [[F0:%.*]] = load i8**
66 // CHECK-NEXT: [[F1:%.*]] = bitcast i8* [[F0]] to void (i8*, i8**)*
67 // CHECK-NEXT: call void [[F1]](i8* [[BLOCK]], i8** [[TEMP]])
68 // CHECK-NEXT: [[T0:%.*]] = load i8** [[TEMP]]
69 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retain(i8* [[T0]])
70 // CHECK-NEXT: [[T2:%.*]] = load i8** [[STRONG]]
71 // CHECK-NEXT: store i8* [[T1]], i8** [[STRONG]]
72 // CHECK-NEXT: call void @objc_release(i8* [[T2]])
73
74 // CHECK-NEXT: [[T0:%.*]] = load i8** [[STRONG]]
75 // CHECK-NEXT: call void @objc_release(i8* [[T0]])
76
77 // CHECK-NEXT: load void (i8**)** [[SINK]]
78 // CHECK-NEXT: bitcast
79 // CHECK-NEXT: call void @objc_release
80 // CHECK-NEXT: ret void
81
82}
83
84void test4(void) {
85 id test4_source(void);
86 void test4_helper(void (^)(void));
87 __block id var = test4_source();
88 test4_helper(^{ var = 0; });
89
90 // CHECK: define void @test4()
91 // CHECK: [[VAR:%.*]] = alloca [[BYREF_T:%.*]],
92 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
93 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 2
94 // 0x02000000 - has copy/dispose helpers
95 // CHECK-NEXT: store i32 33554432, i32* [[T0]]
96 // CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 6
97 // CHECK-NEXT: [[T0:%.*]] = call i8* @test4_source()
98 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
99 // CHECK-NEXT: store i8* [[T1]], i8** [[SLOT]]
100 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 6
101 // 0x42000000 - has signature, copy/dispose helpers
102 // CHECK: store i32 1107296256,
103 // CHECK: [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
104 // CHECK-NEXT: store i8* [[T0]], i8**
105 // CHECK: call void @test4_helper(
106 // CHECK: [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
107 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
108 // CHECK-NEXT: [[T0:%.*]] = load i8** [[SLOT]]
109 // CHECK-NEXT: call void @objc_release(i8* [[T0]])
110 // CHECK-NEXT: ret void
111
112 // CHECK: define internal void @__Block_byref_object_copy_
113 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
114 // CHECK-NEXT: load i8**
115 // CHECK-NEXT: bitcast i8* {{%.*}} to [[BYREF_T]]*
116 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
117 // CHECK-NEXT: [[T2:%.*]] = load i8** [[T1]]
118 // CHECK-NEXT: store i8* [[T2]], i8** [[T0]]
119 // CHECK-NEXT: store i8* null, i8** [[T1]]
120
121 // CHECK: define internal void @__Block_byref_object_dispose_
122 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
123 // CHECK-NEXT: [[T1:%.*]] = load i8** [[T0]]
124 // CHECK-NEXT: call void @objc_release(i8* [[T1]])
125
126 // CHECK: define internal void @__test4_block_invoke_
127 // CHECK: [[SLOT:%.*]] = getelementptr inbounds {{.*}}, i32 0, i32 6
128 // CHECK-NEXT: [[T0:%.*]] = load i8** [[SLOT]], align 8
129 // CHECK-NEXT: store i8* null, i8** [[SLOT]],
130 // CHECK-NEXT: call void @objc_release(i8* [[T0]])
131 // CHECK-NEXT: ret void
132
133 // CHECK: define internal void @__copy_helper_block_
134 // CHECK: call void @_Block_object_assign(i8* {{%.*}}, i8* {{%.*}}, i32 8)
135
136 // CHECK: define internal void @__destroy_helper_block_
137 // CHECK: call void @_Block_object_dispose(i8* {{%.*}}, i32 8)
138}
139
140void test5(void) {
141 extern id test5_source(void);
142 void test5_helper(void (^)(void));
143 __unsafe_unretained id var = test5_source();
144 test5_helper(^{ (void) var; });
145
146 // CHECK: define void @test5()
147 // CHECK: [[VAR:%.*]] = alloca i8*
148 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
149 // CHECK: [[T0:%.*]] = call i8* @test5_source()
150 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
151 // CHECK-NEXT: store i8* [[T1]], i8** [[VAR]],
152 // CHECK-NEXT: call void @objc_release(i8* [[T1]])
153 // 0x40000000 - has signature but no copy/dispose
154 // CHECK: store i32 1073741824, i32*
155 // CHECK: [[CAPTURE:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
156 // CHECK-NEXT: [[T0:%.*]] = load i8** [[VAR]]
157 // CHECK-NEXT: store i8* [[T0]], i8** [[CAPTURE]]
158 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to
159 // CHECK: call void @test5_helper
160 // CHECK-NEXT: ret void
161}
162
163void test6(void) {
164 id test6_source(void);
165 void test6_helper(void (^)(void));
166 __block __weak id var = test6_source();
167 test6_helper(^{ var = 0; });
168
169 // CHECK: define void @test6()
170 // CHECK: [[VAR:%.*]] = alloca [[BYREF_T:%.*]],
171 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
172 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 2
173 // 0x02000000 - has copy/dispose helpers
174 // CHECK-NEXT: store i32 33554432, i32* [[T0]]
175 // CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 6
176 // CHECK-NEXT: [[T0:%.*]] = call i8* @test6_source()
177 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
178 // CHECK-NEXT: call i8* @objc_initWeak(i8** [[SLOT]], i8* [[T1]])
179 // CHECK-NEXT: call void @objc_release(i8* [[T1]])
180 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[VAR]], i32 0, i32 6
181 // 0x42000000 - has signature, copy/dispose helpers
182 // CHECK: store i32 1107296256,
183 // CHECK: [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
184 // CHECK-NEXT: store i8* [[T0]], i8**
185 // CHECK: call void @test6_helper(
186 // CHECK: [[T0:%.*]] = bitcast [[BYREF_T]]* [[VAR]] to i8*
187 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
188 // CHECK-NEXT: call void @objc_destroyWeak(i8** [[SLOT]])
189 // CHECK-NEXT: ret void
190
191 // CHECK: define internal void @__Block_byref_object_copy_
192 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
193 // CHECK-NEXT: load i8**
194 // CHECK-NEXT: bitcast i8* {{%.*}} to [[BYREF_T]]*
195 // CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
196 // CHECK-NEXT: call void @objc_moveWeak(i8** [[T0]], i8** [[T1]])
197
198 // CHECK: define internal void @__Block_byref_object_dispose_
199 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* {{%.*}}, i32 0, i32 6
200 // CHECK-NEXT: call void @objc_destroyWeak(i8** [[T0]])
201
202 // CHECK: define internal void @__test6_block_invoke_
203 // CHECK: [[SLOT:%.*]] = getelementptr inbounds {{.*}}, i32 0, i32 6
204 // CHECK-NEXT: call i8* @objc_storeWeak(i8** [[SLOT]], i8* null)
205 // CHECK-NEXT: ret void
206
207 // CHECK: define internal void @__copy_helper_block_
208 // 0x8 - FIELD_IS_BYREF (no FIELD_IS_WEAK because clang in control)
209 // CHECK: call void @_Block_object_assign(i8* {{%.*}}, i8* {{%.*}}, i32 8)
210
211 // CHECK: define internal void @__destroy_helper_block_
212 // 0x8 - FIELD_IS_BYREF (no FIELD_IS_WEAK because clang in control)
213 // CHECK: call void @_Block_object_dispose(i8* {{%.*}}, i32 8)
214}
215
216void test7(void) {
217 id test7_source(void);
218 void test7_helper(void (^)(void));
219 void test7_consume(id);
220 __weak id var = test7_source();
221 test7_helper(^{ test7_consume(var); });
222
223 // CHECK: define void @test7()
224 // CHECK: [[VAR:%.*]] = alloca i8*,
225 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
226 // CHECK: [[T0:%.*]] = call i8* @test7_source()
227 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainAutoreleasedReturnValue(i8* [[T0]])
228 // CHECK-NEXT: call i8* @objc_initWeak(i8** [[VAR]], i8* [[T1]])
229 // CHECK-NEXT: call void @objc_release(i8* [[T1]])
230 // 0x42000000 - has signature, copy/dispose helpers
231 // CHECK: store i32 1107296256,
232 // CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
233 // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_loadWeak(i8** [[VAR]])
234 // CHECK-NEXT: call i8* @objc_initWeak(i8** [[SLOT]], i8* [[T0]])
235 // CHECK: call void @test7_helper(
236 // CHECK-NEXT: call void @objc_destroyWeak(i8** [[SLOT]])
237 // CHECK-NEXT: call void @objc_destroyWeak(i8** [[VAR]])
238 // CHECK-NEXT: ret void
239
240 // CHECK: define internal void @__test7_block_invoke_
241 // CHECK: [[SLOT:%.*]] = getelementptr inbounds [[BLOCK_T]]* {{%.*}}, i32 0, i32 5
242 // CHECK-NEXT: [[T0:%.*]] = call i8* @objc_loadWeak(i8** [[SLOT]])
243 // CHECK-NEXT: call void @test7_consume(i8* [[T0]])
244 // CHECK-NEXT: ret void
245
246 // CHECK: define internal void @__copy_helper_block_
247 // CHECK: getelementptr
248 // CHECK-NEXT: getelementptr
249 // CHECK-NEXT: call void @objc_copyWeak(
250
251 // CHECK: define internal void @__destroy_helper_block_
252 // CHECK: getelementptr
253 // CHECK-NEXT: call void @objc_destroyWeak(
254}
255
256@interface Test8 @end
257@implementation Test8
258- (void) test {
259// CHECK: define internal void @"\01-[Test8 test]"
260// CHECK: [[SELF:%.*]] = alloca [[TEST8:%.*]]*,
261// CHECK-NEXT: alloca i8*
262// CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]],
263// CHECK: store
264// CHECK-NEXT: store
265// CHECK: [[T0:%.*]] = getelementptr inbounds [[BLOCK_T]]* [[BLOCK]], i32 0, i32 5
266// CHECK-NEXT: [[T1:%.*]] = load [[TEST8]]** [[SELF]],
267// CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST8]]* [[T1]] to i8*
268// CHECK-NEXT: [[T3:%.*]] = call i8* @objc_retain(i8* [[T2]])
269// CHECK-NEXT: [[T4:%.*]] = bitcast i8* [[T3]] to [[TEST8]]*
270// CHECK-NEXT: store [[TEST8]]* [[T4]], [[TEST8]]** [[T0]]
271// CHECK-NEXT: bitcast [[BLOCK_T]]* [[BLOCK]] to
272// CHECK: call void @test8_helper(
273// CHECK-NEXT: [[T1:%.*]] = load [[TEST8]]** [[T0]]
274// CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST8]]* [[T1]] to i8*
275// CHECK-NEXT: call void @objc_release(i8* [[T2]])
276// CHECK-NEXT: ret void
277
278 extern void test8_helper(void (^)(void));
279 test8_helper(^{ (void) self; });
280}
281@end
282
283id test9(void) {
284 typedef id __attribute__((ns_returns_retained)) blocktype(void);
285 extern test9_consume_block(blocktype^);
286 return ^blocktype {
287 extern id test9_produce(void);
288 return test9_produce();
289 }();
290
291// CHECK: define i8* @test9(
292// CHECK: load i8** getelementptr
293// CHECK-NEXT: bitcast i8*
294// CHECK-NEXT: call i8*
295// CHECK-NEXT: call i8* @objc_autoreleaseReturnValue
296// CHECK-NEXT: ret i8*
297
298// CHECK: call i8* @test9_produce()
299// CHECK-NEXT: call i8* @objc_retain
300// CHECK-NEXT: ret i8*
301}
302
303// rdar://problem/9814099
304// Test that we correctly initialize __block variables
305// when the initialization captures the variable.
306void test10a(void) {
307 __block void (^block)(void) = ^{ block(); };
308 // CHECK: define void @test10a()
309 // CHECK: [[BYREF:%.*]] = alloca [[BYREF_T:%.*]],
310
311 // Zero-initialization before running the initializer.
312 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 6
313 // CHECK-NEXT: store void ()* null, void ()** [[T0]], align 8
314
315 // Run the initializer as an assignment.
316 // CHECK: [[T0:%.*]] = bitcast void ()* {{%.*}} to i8*
317 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainBlock(i8* [[T0]])
318 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()*
319 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 1
320 // CHECK-NEXT: [[T4:%.*]] = load [[BYREF_T]]** [[T3]]
321 // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[BYREF_T]]* [[T4]], i32 0, i32 6
322 // CHECK-NEXT: [[T6:%.*]] = load void ()** [[T5]], align 8
323 // CHECK-NEXT: store void ()* {{%.*}}, void ()** [[T5]], align 8
324 // CHECK-NEXT: [[T7:%.*]] = bitcast void ()* [[T6]] to i8*
325 // CHECK-NEXT: call void @objc_release(i8* [[T7]])
326
327 // Destroy at end of function.
328 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 6
329 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BYREF_T]]* [[BYREF]] to i8*
330 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
331 // CHECK-NEXT: [[T1:%.*]] = load void ()** [[SLOT]]
332 // CHECK-NEXT: [[T2:%.*]] = bitcast void ()* [[T1]] to i8*
333 // CHECK-NEXT: call void @objc_release(i8* [[T2]])
334 // CHECK-NEXT: ret void
335}
336
John McCalla59e4b72011-11-09 03:17:26 +0000[diff] [blame^]337// <rdar://problem/10402698>: do this copy and dispose with
338// objc_retainBlock/release instead of _Block_object_assign/destroy.
339// We can also use _Block_object_assign/destroy with
340// BLOCK_FIELD_IS_BLOCK as long as we don't pass BLOCK_BYREF_CALLER.
341
342// CHECK: define internal void @__Block_byref_object_copy
343// CHECK: [[D0:%.*]] = load i8** {{%.*}}
344// CHECK-NEXT: [[D1:%.*]] = bitcast i8* [[D0]] to [[BYREF_T]]*
345// CHECK-NEXT: [[D2:%.*]] = getelementptr inbounds [[BYREF_T]]* [[D1]], i32 0, i32 6
346// CHECK-NEXT: [[S0:%.*]] = load i8** {{%.*}}
347// CHECK-NEXT: [[S1:%.*]] = bitcast i8* [[S0]] to [[BYREF_T]]*
348// CHECK-NEXT: [[S2:%.*]] = getelementptr inbounds [[BYREF_T]]* [[S1]], i32 0, i32 6
349// CHECK-NEXT: [[T0:%.*]] = load void ()** [[S2]], align 8
350// CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
351// CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
352// CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
353// CHECK-NEXT: store void ()* [[T3]], void ()** [[D2]], align 8
354// CHECK-NEXT: ret void
355
356// CHECK: define internal void @__Block_byref_object_dispose
357// CHECK: [[T0:%.*]] = load i8** {{%.*}}
358// CHECK-NEXT: [[T1:%.*]] = bitcast i8* [[T0]] to [[BYREF_T]]*
359// CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [[BYREF_T]]* [[T1]], i32 0, i32 6
360// CHECK-NEXT: [[T3:%.*]] = load void ()** [[T2]], align 8
361// CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8*
362// CHECK-NEXT: call void @objc_release(i8* [[T4]])
363// CHECK-NEXT: ret void
364
John McCall3382f652011-11-09 02:16:13 +0000[diff] [blame]365// Test that we correctly assign to __block variables when the
366// assignment captures the variable.
367void test10b(void) {
368 __block void (^block)(void);
369 block = ^{ block(); };
370
371 // CHECK: define void @test10b()
372 // CHECK: [[BYREF:%.*]] = alloca [[BYREF_T:%.*]],
373
374 // Zero-initialize.
375 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 6
376 // CHECK-NEXT: store void ()* null, void ()** [[T0]], align 8
377
378 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 6
379
380 // The assignment.
381 // CHECK: [[T0:%.*]] = bitcast void ()* {{%.*}} to i8*
382 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainBlock(i8* [[T0]])
383 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()*
384 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 1
385 // CHECK-NEXT: [[T4:%.*]] = load [[BYREF_T]]** [[T3]]
386 // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[BYREF_T]]* [[T4]], i32 0, i32 6
387 // CHECK-NEXT: [[T6:%.*]] = load void ()** [[T5]], align 8
388 // CHECK-NEXT: store void ()* {{%.*}}, void ()** [[T5]], align 8
389 // CHECK-NEXT: [[T7:%.*]] = bitcast void ()* [[T6]] to i8*
390 // CHECK-NEXT: call void @objc_release(i8* [[T7]])
391
392 // Destroy at end of function.
393 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BYREF_T]]* [[BYREF]] to i8*
394 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
395 // CHECK-NEXT: [[T1:%.*]] = load void ()** [[SLOT]]
396 // CHECK-NEXT: [[T2:%.*]] = bitcast void ()* [[T1]] to i8*
397 // CHECK-NEXT: call void @objc_release(i8* [[T2]])
398 // CHECK-NEXT: ret void
399}
400
401// rdar://problem/10088932
402void test11_helper(id);
403void test11a(void) {
404 int x;
405 test11_helper(^{ (void) x; });
406
407 // CHECK: define void @test11a()
408 // CHECK: [[X:%.*]] = alloca i32, align 4
409 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8
410 // CHECK: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void ()*
411 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
412 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
413 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
414 // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8*
415 // CHECK-NEXT: call void @test11_helper(i8* [[T4]])
416 // CHECK-NEXT: [[T5:%.*]] = bitcast void ()* [[T3]] to i8*
417 // CHECK-NEXT: call void @objc_release(i8* [[T5]])
418 // CHECK-NEXT: ret void
419}
420void test11b(void) {
421 int x;
422 id b = ^{ (void) x; };
423
424 // CHECK: define void @test11b()
425 // CHECK: [[X:%.*]] = alloca i32, align 4
426 // CHECK-NEXT: [[B:%.*]] = alloca i8*, align 8
427 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8
428 // CHECK: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void ()*
429 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
430 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
431 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
432 // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8*
433 // CHECK-NEXT: store i8* [[T4]], i8** [[B]], align 8
434 // CHECK-NEXT: [[T5:%.*]] = load i8** [[B]]
435 // CHECK-NEXT: call void @objc_release(i8* [[T5]])
436 // CHECK-NEXT: ret void
437}
438
439// rdar://problem/9979150
440@interface Test12
441@property (strong) void(^ablock)(void);
442@property (nonatomic, strong) void(^nblock)(void);
443@end
444@implementation Test12
445@synthesize ablock, nblock;
446// CHECK: define internal void ()* @"\01-[Test12 ablock]"(
447// CHECK: call i8* @objc_getProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i1 zeroext true)
448
449// CHECK: define internal void @"\01-[Test12 setAblock:]"(
450// CHECK: call void @objc_setProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i8* {{%.*}}, i1 zeroext true, i1 zeroext true)
451
452// CHECK: define internal void ()* @"\01-[Test12 nblock]"(
453// CHECK: call i8* @objc_getProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i1 zeroext false)
454
455// CHECK: define internal void @"\01-[Test12 setNblock:]"(
456// CHECK: call void @objc_setProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i8* {{%.*}}, i1 zeroext false, i1 zeroext true)
457@end