Mercurial > hg > CbC > CbC_llvm

annotate clang/test/CodeGenObjC/arc-precise-lifetime.m @ 180:680fa57a2f20

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