Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / external / clang / 3382f65767976f4839bbe463966976e9215672cf / . / test / CodeGenObjC / arc-blocks.m
blob: 50fdd0a12c775beb8c42bad76b65a0c281d03070 [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
337// Test that we correctly assign to __block variables when the
338// assignment captures the variable.
339void test10b(void) {
340 __block void (^block)(void);
341 block = ^{ block(); };
342
343 // CHECK: define void @test10b()
344 // CHECK: [[BYREF:%.*]] = alloca [[BYREF_T:%.*]],
345
346 // Zero-initialize.
347 // CHECK: [[T0:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 6
348 // CHECK-NEXT: store void ()* null, void ()** [[T0]], align 8
349
350 // CHECK-NEXT: [[SLOT:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 6
351
352 // The assignment.
353 // CHECK: [[T0:%.*]] = bitcast void ()* {{%.*}} to i8*
354 // CHECK-NEXT: [[T1:%.*]] = call i8* @objc_retainBlock(i8* [[T0]])
355 // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to void ()*
356 // CHECK-NEXT: [[T3:%.*]] = getelementptr inbounds [[BYREF_T]]* [[BYREF]], i32 0, i32 1
357 // CHECK-NEXT: [[T4:%.*]] = load [[BYREF_T]]** [[T3]]
358 // CHECK-NEXT: [[T5:%.*]] = getelementptr inbounds [[BYREF_T]]* [[T4]], i32 0, i32 6
359 // CHECK-NEXT: [[T6:%.*]] = load void ()** [[T5]], align 8
360 // CHECK-NEXT: store void ()* {{%.*}}, void ()** [[T5]], align 8
361 // CHECK-NEXT: [[T7:%.*]] = bitcast void ()* [[T6]] to i8*
362 // CHECK-NEXT: call void @objc_release(i8* [[T7]])
363
364 // Destroy at end of function.
365 // CHECK-NEXT: [[T0:%.*]] = bitcast [[BYREF_T]]* [[BYREF]] to i8*
366 // CHECK-NEXT: call void @_Block_object_dispose(i8* [[T0]], i32 8)
367 // CHECK-NEXT: [[T1:%.*]] = load void ()** [[SLOT]]
368 // CHECK-NEXT: [[T2:%.*]] = bitcast void ()* [[T1]] to i8*
369 // CHECK-NEXT: call void @objc_release(i8* [[T2]])
370 // CHECK-NEXT: ret void
371}
372
373// rdar://problem/10088932
374void test11_helper(id);
375void test11a(void) {
376 int x;
377 test11_helper(^{ (void) x; });
378
379 // CHECK: define void @test11a()
380 // CHECK: [[X:%.*]] = alloca i32, align 4
381 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8
382 // CHECK: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void ()*
383 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
384 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
385 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
386 // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8*
387 // CHECK-NEXT: call void @test11_helper(i8* [[T4]])
388 // CHECK-NEXT: [[T5:%.*]] = bitcast void ()* [[T3]] to i8*
389 // CHECK-NEXT: call void @objc_release(i8* [[T5]])
390 // CHECK-NEXT: ret void
391}
392void test11b(void) {
393 int x;
394 id b = ^{ (void) x; };
395
396 // CHECK: define void @test11b()
397 // CHECK: [[X:%.*]] = alloca i32, align 4
398 // CHECK-NEXT: [[B:%.*]] = alloca i8*, align 8
399 // CHECK-NEXT: [[BLOCK:%.*]] = alloca [[BLOCK_T:<{.*}>]], align 8
400 // CHECK: [[T0:%.*]] = bitcast [[BLOCK_T]]* [[BLOCK]] to void ()*
401 // CHECK-NEXT: [[T1:%.*]] = bitcast void ()* [[T0]] to i8*
402 // CHECK-NEXT: [[T2:%.*]] = call i8* @objc_retainBlock(i8* [[T1]])
403 // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to void ()*
404 // CHECK-NEXT: [[T4:%.*]] = bitcast void ()* [[T3]] to i8*
405 // CHECK-NEXT: store i8* [[T4]], i8** [[B]], align 8
406 // CHECK-NEXT: [[T5:%.*]] = load i8** [[B]]
407 // CHECK-NEXT: call void @objc_release(i8* [[T5]])
408 // CHECK-NEXT: ret void
409}
410
411// rdar://problem/9979150
412@interface Test12
413@property (strong) void(^ablock)(void);
414@property (nonatomic, strong) void(^nblock)(void);
415@end
416@implementation Test12
417@synthesize ablock, nblock;
418// CHECK: define internal void ()* @"\01-[Test12 ablock]"(
419// CHECK: call i8* @objc_getProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i1 zeroext true)
420
421// CHECK: define internal void @"\01-[Test12 setAblock:]"(
422// CHECK: call void @objc_setProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i8* {{%.*}}, i1 zeroext true, i1 zeroext true)
423
424// CHECK: define internal void ()* @"\01-[Test12 nblock]"(
425// CHECK: call i8* @objc_getProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i1 zeroext false)
426
427// CHECK: define internal void @"\01-[Test12 setNblock:]"(
428// CHECK: call void @objc_setProperty(i8* {{%.*}}, i8* {{%.*}}, i64 {{%.*}}, i8* {{%.*}}, i1 zeroext false, i1 zeroext true)
429@end
430