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// <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
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
458