Clang Project

clang_source_code/test/CodeGenObjC/arc-precise-lifetime.m
1// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-passes -o - %s | FileCheck %s
2
3#define PRECISE_LIFETIME __attribute__((objc_precise_lifetime))
4
5id test0_helper(void) __attribute__((ns_returns_retained));
6void test0() {
7  PRECISE_LIFETIME id x = test0_helper();
8  x = 0;
9  // CHECK:      [[X:%.*]] = alloca i8*
10  // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8*
11  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]])
12  // CHECK-NEXT: [[CALL:%.*]] = call i8* @test0_helper()
13  // CHECK-NEXT: store i8* [[CALL]], i8** [[X]]
14
15  // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
16  // CHECK-NEXT: store i8* null, i8** [[X]]
17  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW:#[0-9]+]]
18  // CHECK-NOT:  clang.imprecise_release
19
20  // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** [[X]]
21  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW:#[0-9]+]]
22  // CHECK-NOT:  clang.imprecise_release
23
24  // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8*
25  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
26  // CHECK-NEXT: ret void
27}
28
29// rdar://problem/9821110 - precise lifetime should suppress extension
30// rdar://problem/22172983 - should work for calls via property syntax, too
31@interface Test1
32- (char*) interior __attribute__((objc_returns_inner_pointer));
33// Should we allow this on properties? Yes! see // rdar://14990439
34@property (nonatomic, readonly) char * PropertyReturnsInnerPointer __attribute__((objc_returns_inner_pointer));
35@end
36extern Test1 *test1_helper(void);
37
38// CHECK-LABEL: define void @test1a_message()
39void test1a_message(void) {
40  // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
41  // CHECK:      [[C:%.*]] = alloca i8*, align 8
42  // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
43  // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
44  // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
45  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
46  // CHECK-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
47  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
48  // CHECK-NEXT: store [[TEST1]]* [[T3]]
49  // CHECK-NEXT: [[CPTR1:%.*]] = bitcast i8** [[C]] to i8*
50  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CPTR1]])
51  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
52  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
53  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
54  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
55  // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
56  // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8*
57  // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast
58  // CHECK-NEXT: store i8* [[T6]], i8**
59  // CHECK-NEXT: [[CPTR2:%.*]] = bitcast i8** [[C]] to i8*
60  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CPTR2]])
61  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
62  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
63  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
64  // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
65  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
66  // CHECK-NEXT: ret void
67  Test1 *ptr = test1_helper();
68  char *c = [(ptr) interior];
69}
70
71
72// CHECK-LABEL: define void @test1a_property()
73void test1a_property(void) {
74  // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
75  // CHECK:      [[C:%.*]] = alloca i8*, align 8
76  // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
77  // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
78  // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
79  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
80  // CHECK-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
81  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
82  // CHECK-NEXT: store [[TEST1]]* [[T3]]
83  // CHECK-NEXT: [[CPTR1:%.*]] = bitcast i8** [[C]] to i8*
84  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CPTR1]])
85  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
86  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
87  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
88  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
89  // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
90  // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8*
91  // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast
92  // CHECK-NEXT: store i8* [[T6]], i8**
93  // CHECK-NEXT: [[CPTR2:%.*]] = bitcast i8** [[C]] to i8*
94  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CPTR2]])
95  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
96  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
97  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
98  // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
99  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
100  // CHECK-NEXT: ret void
101  Test1 *ptr = test1_helper();
102  char *c = ptr.interior;
103}
104
105
106// CHECK-LABEL: define void @test1b_message()
107void test1b_message(void) {
108  // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
109  // CHECK:      [[C:%.*]] = alloca i8*, align 8
110  // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
111  // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
112  // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
113  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
114  // CHECK-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
115  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
116  // CHECK-NEXT: store [[TEST1]]* [[T3]]
117  // CHECK-NEXT: [[CPTR1:%.*]] = bitcast i8** [[C]] to i8*
118  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CPTR1]])
119  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
120  // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
121  // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
122  // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast
123  // CHECK-NEXT: store i8* [[T3]], i8**
124  // CHECK-NEXT: [[CPTR2:%.*]] = bitcast i8** [[C]] to i8*
125  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CPTR2]])
126  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
127  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
128  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]]
129  // CHECK-NOT:  clang.imprecise_release
130  // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
131  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
132  // CHECK-NEXT: ret void
133  PRECISE_LIFETIME Test1 *ptr = test1_helper();
134  char *c = [ptr interior];
135}
136
137// CHECK-LABEL: define void @test1b_property()
138void test1b_property(void) {
139  // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
140  // CHECK:      [[C:%.*]] = alloca i8*, align 8
141  // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
142  // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
143  // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
144  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
145  // CHECK-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
146  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
147  // CHECK-NEXT: store [[TEST1]]* [[T3]]
148  // CHECK-NEXT: [[CPTR1:%.*]] = bitcast i8** [[C]] to i8*
149  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[CPTR1]])
150  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
151  // CHECK-NEXT: [[T1:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
152  // CHECK-NEXT: [[T2:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
153  // CHECK-NEXT: [[T3:%.*]] = call i8* bitcast
154  // CHECK-NEXT: store i8* [[T3]], i8**
155  // CHECK-NEXT: [[CPTR2:%.*]] = bitcast i8** [[C]] to i8*
156  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[CPTR2]])
157  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
158  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
159  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]]
160  // CHECK-NOT:  clang.imprecise_release
161  // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
162  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
163  // CHECK-NEXT: ret void
164  PRECISE_LIFETIME Test1 *ptr = test1_helper();
165  char *c = ptr.interior;
166}
167
168// CHECK-LABEL: define void @test1c_message()
169void test1c_message(void) {
170  // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
171  // CHECK:      [[PC:%.*]] = alloca i8*, align 8
172  // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
173  // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
174  // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
175  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
176  // CHECK-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
177  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
178  // CHECK-NEXT: store [[TEST1]]* [[T3]]
179  // CHECK-NEXT: [[PCPTR1:%.*]] = bitcast i8** [[PC]] to i8*
180  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PCPTR1]])
181  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
182  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
183  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
184  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
185  // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
186  // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8*
187  // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast
188  // CHECK-NEXT: store i8* [[T6]], i8**
189  // CHECK-NEXT: [[PCPTR2:%.*]] = bitcast i8** [[PC]] to i8*
190  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PCPTR2]])
191  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
192  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
193  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
194  // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
195  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
196  // CHECK-NEXT: ret void
197  Test1 *ptr = test1_helper();
198  char *pc = [ptr PropertyReturnsInnerPointer];
199}
200
201// CHECK-LABEL: define void @test1c_property()
202void test1c_property(void) {
203  // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
204  // CHECK:      [[PC:%.*]] = alloca i8*, align 8
205  // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
206  // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
207  // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
208  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
209  // CHECK-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
210  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
211  // CHECK-NEXT: store [[TEST1]]* [[T3]]
212  // CHECK-NEXT: [[PCPTR1:%.*]] = bitcast i8** [[PC]] to i8*
213  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PCPTR1]])
214  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
215  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
216  // CHECK-NEXT: [[T2:%.*]] = call i8* @llvm.objc.retainAutorelease(i8* [[T1]])
217  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
218  // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
219  // CHECK-NEXT: [[T5:%.*]] = bitcast [[TEST1]]* [[T3]] to i8*
220  // CHECK-NEXT: [[T6:%.*]] = call i8* bitcast
221  // CHECK-NEXT: store i8* [[T6]], i8**
222  // CHECK-NEXT: [[PCPTR2:%.*]] = bitcast i8** [[PC]] to i8*
223  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PCPTR2]])
224  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
225  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
226  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
227  // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
228  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
229  // CHECK-NEXT: ret void
230  Test1 *ptr = test1_helper();
231  char *pc = ptr.PropertyReturnsInnerPointer;
232}
233
234// CHECK-LABEL: define void @test1d_message()
235void test1d_message(void) {
236  // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
237  // CHECK:      [[PC:%.*]] = alloca i8*, align 8
238  // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
239  // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
240  // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
241  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
242  // CHECK-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
243  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
244  // CHECK-NEXT: store [[TEST1]]* [[T3]]
245  // CHECK-NEXT: [[PCPTR1:%.*]] = bitcast i8** [[PC]] to i8*
246  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PCPTR1]])
247  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
248  // CHECK-NEXT: [[SEVEN:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
249  // CHECK-NEXT: [[EIGHT:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
250  // CHECK-NEXT: [[CALL1:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* [[EIGHT]], i8* [[SEVEN]])
251  // CHECK-NEXT: store i8* [[CALL1]], i8**
252  // CHECK-NEXT: [[PCPTR2:%.*]] = bitcast i8** [[PC]] to i8*
253  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PCPTR2]])
254  // CHECK-NEXT: [[NINE:%.*]] = load [[TEST1]]*, [[TEST1]]**
255  // CHECK-NEXT: [[TEN:%.*]] = bitcast [[TEST1]]* [[NINE]] to i8*
256  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TEN]])
257  // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
258  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
259  // CHECK-NEXT: ret void
260  PRECISE_LIFETIME Test1 *ptr = test1_helper();
261  char *pc = [ptr PropertyReturnsInnerPointer];
262}
263
264// CHECK-LABEL: define void @test1d_property()
265void test1d_property(void) {
266  // CHECK:      [[PTR:%.*]] = alloca [[PTR_T:%.*]]*, align 8
267  // CHECK:      [[PC:%.*]] = alloca i8*, align 8
268  // CHECK:      [[PTRPTR1:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
269  // CHECK:      call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PTRPTR1]])
270  // CHECK:      [[T0:%.*]] = call [[TEST1:%.*]]* @test1_helper()
271  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
272  // CHECK-NEXT: [[T2:%.*]] = notail call i8* @llvm.objc.retainAutoreleasedReturnValue(i8* [[T1]])
273  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to [[TEST1]]*
274  // CHECK-NEXT: store [[TEST1]]* [[T3]]
275  // CHECK-NEXT: [[PCPTR1:%.*]] = bitcast i8** [[PC]] to i8*
276  // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[PCPTR1]])
277  // CHECK-NEXT: [[T0:%.*]] = load [[TEST1]]*, [[TEST1]]**
278  // CHECK-NEXT: [[SEVEN:%.*]] = load i8*, i8** @OBJC_SELECTOR_REFERENCES_
279  // CHECK-NEXT: [[EIGHT:%.*]] = bitcast [[TEST1]]* [[T0]] to i8*
280  // CHECK-NEXT: [[CALL1:%.*]] = call i8* bitcast (i8* (i8*, i8*, ...)* @objc_msgSend to i8* (i8*, i8*)*)(i8* [[EIGHT]], i8* [[SEVEN]])
281  // CHECK-NEXT: store i8* [[CALL1]], i8**
282  // CHECK-NEXT: [[PCPTR2:%.*]] = bitcast i8** [[PC]] to i8*
283  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PCPTR2]])
284  // CHECK-NEXT: [[NINE:%.*]] = load [[TEST1]]*, [[TEST1]]**
285  // CHECK-NEXT: [[TEN:%.*]] = bitcast [[TEST1]]* [[NINE]] to i8*
286  // CHECK-NEXT: call void @llvm.objc.release(i8* [[TEN]])
287  // CHECK-NEXT: [[PTRPTR2:%.*]] = bitcast [[PTR_T]]** [[PTR]] to i8*
288  // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[PTRPTR2]])
289  // CHECK-NEXT: ret void
290  PRECISE_LIFETIME Test1 *ptr = test1_helper();
291  char *pc = ptr.PropertyReturnsInnerPointer;
292}
293
294@interface Test2 {
295@public
296  id ivar;
297}
298@end
299// CHECK-LABEL:      define void @test2(
300void test2(Test2 *x) {
301  x->ivar = 0;
302  // CHECK:      [[X:%.*]] = alloca [[TEST2:%.*]]*
303  // CHECK-NEXT: [[T0:%.*]] = bitcast [[TEST2]]* {{%.*}} to i8*
304  // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) [[NUW]]
305  // CHECK-NEXT: [[T2:%.*]] = bitcast i8* [[T1]] to [[TEST2]]*
306  // CHECK-NEXT: store [[TEST2]]* [[T2]], [[TEST2]]** [[X]],
307
308  // CHECK-NEXT: [[T0:%.*]] = load [[TEST2]]*, [[TEST2]]** [[X]],
309  // CHECK-NEXT: [[OFFSET:%.*]] = load i64, i64* @"OBJC_IVAR_$_Test2.ivar"
310  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST2]]* [[T0]] to i8*
311  // CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds i8, i8* [[T1]], i64 [[OFFSET]]
312  // CHECK-NEXT: [[T3:%.*]] = bitcast i8* [[T2]] to i8**
313  // CHECK-NEXT: [[T4:%.*]] = load i8*, i8** [[T3]],
314  // CHECK-NEXT: store i8* null, i8** [[T3]],
315  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T4]]) [[NUW]]
316  // CHECK-NOT:  imprecise
317
318  // CHECK-NEXT: [[T0:%.*]] = load [[TEST2]]*, [[TEST2]]** [[X]]
319  // CHECK-NEXT: [[T1:%.*]] = bitcast [[TEST2]]* [[T0]] to i8*
320  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T1]]) [[NUW]], !clang.imprecise_release
321
322  // CHECK-NEXT: ret void
323}
324
325// CHECK-LABEL:      define void @test3(i8*
326void test3(PRECISE_LIFETIME id x) {
327  // CHECK:      [[X:%.*]] = alloca i8*,
328  // CHECK-NEXT: [[T0:%.*]] = call i8* @llvm.objc.retain(i8* {{%.*}}) [[NUW]]
329  // CHECK-NEXT: store i8* [[T0]], i8** [[X]],
330
331  // CHECK-NEXT: [[T0:%.*]] = load i8*, i8** [[X]]
332  // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]]
333  // CHECK-NOT:  imprecise_release
334
335  // CHECK-NEXT: ret void  
336}
337
338// CHECK: attributes [[NUW]] = { nounwind }
339
CodeThinker, Enjoy your reading code