Mercurial > hg > CbC > CbC_llvm

comparison clang/test/CodeGenObjC/arc-ternary-op.m @ 252:1f2b6ac9f198 llvm-original

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM16-1
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Fri, 18 Aug 2023 09:04:13 +0900
parents c4bab56944e8
children
comparison
equal deleted inserted replaced
237:c80f45b162ad 252:1f2b6ac9f198
1 // RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-apple-darwin10 -emit-llvm -fblocks -fobjc-arc -fobjc-runtime-has-weak -O2 -disable-llvm-passes -o - %s | FileCheck %s 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 2
3 id g0, g1; 3 id g0, g1;
4 4
5 void test0(_Bool cond) { 5 void test0(_Bool cond) {
6 id test0_helper(void) __attribute__((ns_returns_retained)); 6 id test0_helper(void) __attribute__((ns_returns_retained));
7 7
8 // CHECK-LABEL: define{{.*}} void @test0( 8 // CHECK-LABEL: define{{.*}} void @test0(
9 // CHECK: [[COND:%.*]] = alloca i8, 9 // CHECK: [[COND:%.*]] = alloca i8,
10 // CHECK-NEXT: [[X:%.*]] = alloca i8*, 10 // CHECK-NEXT: [[X:%.*]] = alloca ptr,
11 // CHECK-NEXT: [[RELVAL:%.*]] = alloca i8* 11 // CHECK-NEXT: [[RELVAL:%.*]] = alloca ptr
12 // CHECK-NEXT: [[RELCOND:%.*]] = alloca i1 12 // CHECK-NEXT: [[RELCOND:%.*]] = alloca i1
13 // CHECK-NEXT: zext 13 // CHECK-NEXT: zext
14 // CHECK-NEXT: store 14 // CHECK-NEXT: store
15 // CHECK-NEXT: [[XPTR1:%.*]] = bitcast i8** [[X]] to i8* 15 // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 8, ptr [[X]])
16 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[XPTR1]]) 16 // CHECK-NEXT: [[T0:%.*]] = load i8, ptr [[COND]]
17 // CHECK-NEXT: [[T0:%.*]] = load i8, i8* [[COND]]
18 // CHECK-NEXT: [[T1:%.*]] = trunc i8 [[T0]] to i1 17 // CHECK-NEXT: [[T1:%.*]] = trunc i8 [[T0]] to i1
19 // CHECK-NEXT: store i1 false, i1* [[RELCOND]] 18 // CHECK-NEXT: store i1 false, ptr [[RELCOND]]
20 // CHECK-NEXT: br i1 [[T1]], 19 // CHECK-NEXT: br i1 [[T1]],
21 // CHECK: br label 20 // CHECK: br label
22 // CHECK: [[CALL:%.*]] = call i8* @test0_helper() 21 // CHECK: [[CALL:%.*]] = call ptr @test0_helper()
23 // CHECK-NEXT: store i8* [[CALL]], i8** [[RELVAL]] 22 // CHECK-NEXT: store ptr [[CALL]], ptr [[RELVAL]]
24 // CHECK-NEXT: store i1 true, i1* [[RELCOND]] 23 // CHECK-NEXT: store i1 true, ptr [[RELCOND]]
25 // CHECK-NEXT: br label 24 // CHECK-NEXT: br label
26 // CHECK: [[T0:%.*]] = phi i8* [ null, {{%.*}} ], [ [[CALL]], {{%.*}} ] 25 // CHECK: [[T0:%.*]] = phi ptr [ null, {{%.*}} ], [ [[CALL]], {{%.*}} ]
27 // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) [[NUW:#[0-9]+]] 26 // CHECK-NEXT: [[T1:%.*]] = call ptr @llvm.objc.retain(ptr [[T0]]) [[NUW:#[0-9]+]]
28 // CHECK-NEXT: store i8* [[T1]], i8** [[X]], 27 // CHECK-NEXT: store ptr [[T1]], ptr [[X]],
29 // CHECK-NEXT: [[REL:%.*]] = load i1, i1* [[RELCOND]] 28 // CHECK-NEXT: [[REL:%.*]] = load i1, ptr [[RELCOND]]
30 // CHECK-NEXT: br i1 [[REL]], 29 // CHECK-NEXT: br i1 [[REL]],
31 // CHECK: [[T0:%.*]] = load i8*, i8** [[RELVAL]] 30 // CHECK: [[T0:%.*]] = load ptr, ptr [[RELVAL]]
32 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]] 31 // CHECK-NEXT: call void @llvm.objc.release(ptr [[T0]]) [[NUW]]
33 // CHECK-NEXT: br label 32 // CHECK-NEXT: br label
34 // CHECK: [[T0:%.*]] = load i8*, i8** [[X]] 33 // CHECK: [[T0:%.*]] = load ptr, ptr [[X]]
35 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) [[NUW]] 34 // CHECK-NEXT: call void @llvm.objc.release(ptr [[T0]]) [[NUW]]
36 // CHECK-NEXT: [[XPTR2:%.*]] = bitcast i8** [[X]] to i8* 35 // CHECK-NEXT: call void @llvm.lifetime.end.p0(i64 8, ptr [[X]])
37 // CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[XPTR2]])
38 // CHECK-NEXT: ret void 36 // CHECK-NEXT: ret void
39 id x = (cond ? 0 : test0_helper()); 37 id x = (cond ? 0 : test0_helper());
40 } 38 }
41 39
42 void test1(int cond) { 40 void test1(int cond) {
46 test1_sink(cond ? &strong : 0); 44 test1_sink(cond ? &strong : 0);
47 test1_sink(cond ? &weak : 0); 45 test1_sink(cond ? &weak : 0);
48 46
49 // CHECK-LABEL: define{{.*}} void @test1( 47 // CHECK-LABEL: define{{.*}} void @test1(
50 // CHECK: [[COND:%.*]] = alloca i32 48 // CHECK: [[COND:%.*]] = alloca i32
51 // CHECK-NEXT: [[STRONG:%.*]] = alloca i8* 49 // CHECK-NEXT: [[STRONG:%.*]] = alloca ptr
52 // CHECK-NEXT: [[WEAK:%.*]] = alloca i8* 50 // CHECK-NEXT: [[WEAK:%.*]] = alloca ptr
53 // CHECK-NEXT: [[TEMP1:%.*]] = alloca i8* 51 // CHECK-NEXT: [[TEMP1:%.*]] = alloca ptr
54 // CHECK-NEXT: [[TEMP2:%.*]] = alloca i8* 52 // CHECK-NEXT: [[TEMP2:%.*]] = alloca ptr
55 // CHECK-NEXT: [[CONDCLEANUPSAVE:%.*]] = alloca i8* 53 // CHECK-NEXT: [[CONDCLEANUPSAVE:%.*]] = alloca ptr
56 // CHECK-NEXT: [[CONDCLEANUP:%.*]] = alloca i1 54 // CHECK-NEXT: [[CONDCLEANUP:%.*]] = alloca i1
57 // CHECK-NEXT: store i32 55 // CHECK-NEXT: store i32
58 // CHECK-NEXT: [[STRONGPTR1:%.*]] = bitcast i8** [[STRONG]] to i8* 56 // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 8, ptr [[STRONG]])
59 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[STRONGPTR1]]) 57 // CHECK-NEXT: store ptr null, ptr [[STRONG]]
60 // CHECK-NEXT: store i8* null, i8** [[STRONG]] 58 // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 8, ptr [[WEAK]])
61 // CHECK-NEXT: [[WEAKPTR1:%.*]] = bitcast i8** [[WEAK]] to i8* 59 // CHECK-NEXT: call ptr @llvm.objc.initWeak(ptr [[WEAK]], ptr null)
62 // CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 8, i8* [[WEAKPTR1]]) 60
63 // CHECK-NEXT: call i8* @llvm.objc.initWeak(i8** [[WEAK]], i8* null) 61 // CHECK-NEXT: [[T0:%.*]] = load i32, ptr [[COND]]
64
65 // CHECK-NEXT: [[T0:%.*]] = load i32, i32* [[COND]]
66 // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0 62 // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
67 // CHECK: [[ARG:%.*]] = phi i8** 63 // CHECK: [[ARG:%.*]] = phi ptr
68 // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null 64 // CHECK-NEXT: [[T0:%.*]] = icmp eq ptr [[ARG]], null
69 // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i8** null, i8** [[TEMP1]] 65 // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], ptr null, ptr [[TEMP1]]
70 // CHECK-NEXT: br i1 [[T0]], 66 // CHECK-NEXT: br i1 [[T0]],
71 // CHECK: [[T0:%.*]] = load i8*, i8** [[ARG]] 67 // CHECK: [[T0:%.*]] = load ptr, ptr [[ARG]]
72 // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP1]] 68 // CHECK-NEXT: store ptr [[T0]], ptr [[TEMP1]]
73 // CHECK-NEXT: br label 69 // CHECK-NEXT: br label
74 // CHECK: [[W:%.*]] = phi i8* [ [[T0]], {{%.*}} ], [ undef, {{%.*}} ] 70 // CHECK: [[W:%.*]] = phi ptr [ [[T0]], {{%.*}} ], [ undef, {{%.*}} ]
75 // CHECK-NEXT: call void @test1_sink(i8** noundef [[T1]]) 71 // CHECK-NEXT: call void @test1_sink(ptr noundef [[T1]])
76 // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null 72 // CHECK-NEXT: [[T0:%.*]] = icmp eq ptr [[ARG]], null
77 // CHECK-NEXT: br i1 [[T0]], 73 // CHECK-NEXT: br i1 [[T0]],
78 // CHECK: [[T0:%.*]] = load i8*, i8** [[TEMP1]] 74 // CHECK: [[T0:%.*]] = load ptr, ptr [[TEMP1]]
79 // CHECK-NEXT: [[T1:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) 75 // CHECK-NEXT: [[T1:%.*]] = call ptr @llvm.objc.retain(ptr [[T0]])
80 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.use(i8* [[W]]) [[NUW]] 76 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.use(ptr [[W]]) [[NUW]]
81 // CHECK-NEXT: [[T2:%.*]] = load i8*, i8** [[ARG]] 77 // CHECK-NEXT: [[T2:%.*]] = load ptr, ptr [[ARG]]
82 // CHECK-NEXT: store i8* [[T1]], i8** [[ARG]] 78 // CHECK-NEXT: store ptr [[T1]], ptr [[ARG]]
83 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T2]]) 79 // CHECK-NEXT: call void @llvm.objc.release(ptr [[T2]])
84 // CHECK-NEXT: br label 80 // CHECK-NEXT: br label
85 81
86 // CHECK: [[T0:%.*]] = load i32, i32* [[COND]] 82 // CHECK: [[T0:%.*]] = load i32, ptr [[COND]]
87 // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0 83 // CHECK-NEXT: [[T1:%.*]] = icmp ne i32 [[T0]], 0
88 // CHECK: [[ARG:%.*]] = phi i8** 84 // CHECK: [[ARG:%.*]] = phi ptr
89 // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null 85 // CHECK-NEXT: [[T0:%.*]] = icmp eq ptr [[ARG]], null
90 // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], i8** null, i8** [[TEMP2]] 86 // CHECK-NEXT: [[T1:%.*]] = select i1 [[T0]], ptr null, ptr [[TEMP2]]
91 // CHECK-NEXT: store i1 false, i1* [[CONDCLEANUP]] 87 // CHECK-NEXT: store i1 false, ptr [[CONDCLEANUP]]
92 // CHECK-NEXT: br i1 [[T0]], 88 // CHECK-NEXT: br i1 [[T0]],
93 // CHECK: [[T0:%.*]] = call i8* @llvm.objc.loadWeakRetained(i8** [[ARG]]) 89 // CHECK: [[T0:%.*]] = call ptr @llvm.objc.loadWeakRetained(ptr [[ARG]])
94 // CHECK-NEXT: store i8* [[T0]], i8** [[CONDCLEANUPSAVE]] 90 // CHECK-NEXT: store ptr [[T0]], ptr [[CONDCLEANUPSAVE]]
95 // CHECK-NEXT: store i1 true, i1* [[CONDCLEANUP]] 91 // CHECK-NEXT: store i1 true, ptr [[CONDCLEANUP]]
96 // CHECK-NEXT: store i8* [[T0]], i8** [[TEMP2]] 92 // CHECK-NEXT: store ptr [[T0]], ptr [[TEMP2]]
97 // CHECK-NEXT: br label 93 // CHECK-NEXT: br label
98 // CHECK: call void @test1_sink(i8** noundef [[T1]]) 94 // CHECK: call void @test1_sink(ptr noundef [[T1]])
99 // CHECK-NEXT: [[T0:%.*]] = icmp eq i8** [[ARG]], null 95 // CHECK-NEXT: [[T0:%.*]] = icmp eq ptr [[ARG]], null
100 // CHECK-NEXT: br i1 [[T0]], 96 // CHECK-NEXT: br i1 [[T0]],
101 // CHECK: [[T0:%.*]] = load i8*, i8** [[TEMP2]] 97 // CHECK: [[T0:%.*]] = load ptr, ptr [[TEMP2]]
102 // CHECK-NEXT: call i8* @llvm.objc.storeWeak(i8** [[ARG]], i8* [[T0]]) 98 // CHECK-NEXT: call ptr @llvm.objc.storeWeak(ptr [[ARG]], ptr [[T0]])
103 // CHECK-NEXT: br label 99 // CHECK-NEXT: br label
104 100
105 // CHECK: call void @llvm.objc.destroyWeak(i8** [[WEAK]]) 101 // CHECK: call void @llvm.objc.destroyWeak(ptr [[WEAK]])
106 // CHECK: [[WEAKPTR2:%.*]] = bitcast i8** [[WEAK]] to i8* 102 // CHECK: call void @llvm.lifetime.end.p0(i64 8, ptr [[WEAK]])
107 // CHECK: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[WEAKPTR2]]) 103 // CHECK: call void @llvm.lifetime.end.p0(i64 8, ptr [[STRONG]])
108 // CHECK: [[STRONGPTR2:%.*]] = bitcast i8** [[STRONG]] to i8*
109 // CHECK: call void @llvm.lifetime.end.p0i8(i64 8, i8* [[STRONGPTR2]])
110 // CHECK: ret void 104 // CHECK: ret void
111 } 105 }
112 106
113 // rdar://13113981 107 // rdar://13113981
114 // Test that, when emitting an expression at +1 that we can't peephole, 108 // Test that, when emitting an expression at +1 that we can't peephole,
120 for (id obj in cond ? test2_producer() : (void*) 0) { 114 for (id obj in cond ? test2_producer() : (void*) 0) {
121 } 115 }
122 116
123 // CHECK-LABEL: define{{.*}} void @test2( 117 // CHECK-LABEL: define{{.*}} void @test2(
124 // CHECK: [[COND:%.*]] = alloca i32, 118 // CHECK: [[COND:%.*]] = alloca i32,
125 // CHECK: alloca i8* 119 // CHECK: alloca ptr
126 // CHECK: [[CLEANUP_SAVE:%.*]] = alloca i8* 120 // CHECK: [[CLEANUP_SAVE:%.*]] = alloca ptr
127 // CHECK: [[RUN_CLEANUP:%.*]] = alloca i1 121 // CHECK: [[RUN_CLEANUP:%.*]] = alloca i1
128 // Evaluate condition; cleanup disabled by default. 122 // Evaluate condition; cleanup disabled by default.
129 // CHECK: [[T0:%.*]] = load i32, i32* [[COND]], 123 // CHECK: [[T0:%.*]] = load i32, ptr [[COND]],
130 // CHECK-NEXT: icmp ne i32 [[T0]], 0 124 // CHECK-NEXT: icmp ne i32 [[T0]], 0
131 // CHECK-NEXT: store i1 false, i1* [[RUN_CLEANUP]] 125 // CHECK-NEXT: store i1 false, ptr [[RUN_CLEANUP]]
132 // CHECK-NEXT: br i1 126 // CHECK-NEXT: br i1
133 // Within true branch, cleanup enabled. 127 // Within true branch, cleanup enabled.
134 // CHECK: [[T1:%.*]] = call i8* @test2_producer() [ "clang.arc.attachedcall"(i8* (i8*)* @llvm.objc.retainAutoreleasedReturnValue) ] 128 // CHECK: [[T1:%.*]] = call ptr @test2_producer() [ "clang.arc.attachedcall"(ptr @llvm.objc.retainAutoreleasedReturnValue) ]
135 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(i8* [[T1]]) 129 // CHECK-NEXT: call void (...) @llvm.objc.clang.arc.noop.use(ptr [[T1]])
136 // CHECK-NEXT: store i8* [[T1]], i8** [[CLEANUP_SAVE]] 130 // CHECK-NEXT: store ptr [[T1]], ptr [[CLEANUP_SAVE]]
137 // CHECK-NEXT: store i1 true, i1* [[RUN_CLEANUP]] 131 // CHECK-NEXT: store i1 true, ptr [[RUN_CLEANUP]]
138 // CHECK-NEXT: br label 132 // CHECK-NEXT: br label
139 // Join point for conditional operator; retain immediately. 133 // Join point for conditional operator; retain immediately.
140 // CHECK: [[T0:%.*]] = phi i8* [ [[T1]], {{%.*}} ], [ null, {{%.*}} ] 134 // CHECK: [[T0:%.*]] = phi ptr [ [[T1]], {{%.*}} ], [ null, {{%.*}} ]
141 // CHECK-NEXT: [[RESULT:%.*]] = call i8* @llvm.objc.retain(i8* [[T0]]) 135 // CHECK-NEXT: [[RESULT:%.*]] = call ptr @llvm.objc.retain(ptr [[T0]])
142 // Leaving full-expression; run conditional cleanup. 136 // Leaving full-expression; run conditional cleanup.
143 // CHECK-NEXT: [[T0:%.*]] = load i1, i1* [[RUN_CLEANUP]] 137 // CHECK-NEXT: [[T0:%.*]] = load i1, ptr [[RUN_CLEANUP]]
144 // CHECK-NEXT: br i1 [[T0]] 138 // CHECK-NEXT: br i1 [[T0]]
145 // CHECK: [[T0:%.*]] = load i8*, i8** [[CLEANUP_SAVE]] 139 // CHECK: [[T0:%.*]] = load ptr, ptr [[CLEANUP_SAVE]]
146 // CHECK-NEXT: call void @llvm.objc.release(i8* [[T0]]) 140 // CHECK-NEXT: call void @llvm.objc.release(ptr [[T0]])
147 // CHECK-NEXT: br label 141 // CHECK-NEXT: br label
148 // And way down at the end of the loop: 142 // And way down at the end of the loop:
149 // CHECK: call void @llvm.objc.release(i8* [[RESULT]]) 143 // CHECK: call void @llvm.objc.release(ptr [[RESULT]])
150 } 144 }
151 145
152 void test3(int cond) { 146 void test3(int cond) {
153 __strong id *p = cond ? (__strong id[]){g0, g1} : (__strong id[]){g1, g0}; 147 __strong id *p = cond ? (__strong id[]){g0, g1} : (__strong id[]){g1, g0};
154 test2(cond); 148 test2(cond);
155 149
156 // CHECK: define{{.*}} void @test3( 150 // CHECK: define{{.*}} void @test3(
157 // CHECK: %[[P:.*]] = alloca i8**, align 8 151 // CHECK: %[[P:.*]] = alloca ptr, align 8
158 // CHECK: %[[_COMPOUNDLITERAL:.*]] = alloca [2 x i8*], align 8 152 // CHECK: %[[_COMPOUNDLITERAL:.*]] = alloca [2 x ptr], align 8
159 // CHECK: %[[CLEANUP_COND:.*]] = alloca i1, align 1 153 // CHECK: %[[CLEANUP_COND:.*]] = alloca i1, align 1
160 // CHECK: %[[_COMPOUNDLITERAL1:.*]] = alloca [2 x i8*], align 8 154 // CHECK: %[[_COMPOUNDLITERAL1:.*]] = alloca [2 x ptr], align 8
161 // CHECK: %[[CLEANUP_COND4:.*]] = alloca i1, align 1 155 // CHECK: %[[CLEANUP_COND4:.*]] = alloca i1, align 1
162 156
163 // CHECK: %[[ARRAYINIT_BEGIN:.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* %[[_COMPOUNDLITERAL]], i64 0, i64 0 157 // CHECK: %[[ARRAYINIT_BEGIN:.*]] = getelementptr inbounds [2 x ptr], ptr %[[_COMPOUNDLITERAL]], i64 0, i64 0
164 // CHECK: %[[V2:.*]] = load i8*, i8** @g0, align 8 158 // CHECK: %[[V2:.*]] = load ptr, ptr @g0, align 8
165 // CHECK: %[[V3:.*]] = call i8* @llvm.objc.retain(i8* %[[V2]]) 159 // CHECK: %[[V3:.*]] = call ptr @llvm.objc.retain(ptr %[[V2]])
166 // CHECK: store i8* %[[V3]], i8** %[[ARRAYINIT_BEGIN]], align 8 160 // CHECK: store ptr %[[V3]], ptr %[[ARRAYINIT_BEGIN]], align 8
167 // CHECK: %[[ARRAYINIT_ELEMENT:.*]] = getelementptr inbounds i8*, i8** %[[ARRAYINIT_BEGIN]], i64 1 161 // CHECK: %[[ARRAYINIT_ELEMENT:.*]] = getelementptr inbounds ptr, ptr %[[ARRAYINIT_BEGIN]], i64 1
168 // CHECK: %[[V4:.*]] = load i8*, i8** @g1, align 8 162 // CHECK: %[[V4:.*]] = load ptr, ptr @g1, align 8
169 // CHECK: %[[V5:.*]] = call i8* @llvm.objc.retain(i8* %[[V4]]) 163 // CHECK: %[[V5:.*]] = call ptr @llvm.objc.retain(ptr %[[V4]])
170 // CHECK: store i8* %[[V5]], i8** %[[ARRAYINIT_ELEMENT]], align 8 164 // CHECK: store ptr %[[V5]], ptr %[[ARRAYINIT_ELEMENT]], align 8
171 // CHECK: store i1 true, i1* %[[CLEANUP_COND]], align 1 165 // CHECK: store i1 true, ptr %[[CLEANUP_COND]], align 1
172 // CHECK: %[[ARRAYDECAY:.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* %[[_COMPOUNDLITERAL]], i64 0, i64 0 166 // CHECK: %[[ARRAYDECAY:.*]] = getelementptr inbounds [2 x ptr], ptr %[[_COMPOUNDLITERAL]], i64 0, i64 0
173 167
174 // CHECK: %[[ARRAYINIT_BEGIN2:.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* %[[_COMPOUNDLITERAL1]], i64 0, i64 0 168 // CHECK: %[[ARRAYINIT_BEGIN2:.*]] = getelementptr inbounds [2 x ptr], ptr %[[_COMPOUNDLITERAL1]], i64 0, i64 0
175 // CHECK: %[[V6:.*]] = load i8*, i8** @g1, align 8 169 // CHECK: %[[V6:.*]] = load ptr, ptr @g1, align 8
176 // CHECK: %[[V7:.*]] = call i8* @llvm.objc.retain(i8* %[[V6]]) 170 // CHECK: %[[V7:.*]] = call ptr @llvm.objc.retain(ptr %[[V6]])
177 // CHECK: store i8* %[[V7]], i8** %[[ARRAYINIT_BEGIN2]], align 8 171 // CHECK: store ptr %[[V7]], ptr %[[ARRAYINIT_BEGIN2]], align 8
178 // CHECK: %[[ARRAYINIT_ELEMENT3:.*]] = getelementptr inbounds i8*, i8** %[[ARRAYINIT_BEGIN2]], i64 1 172 // CHECK: %[[ARRAYINIT_ELEMENT3:.*]] = getelementptr inbounds ptr, ptr %[[ARRAYINIT_BEGIN2]], i64 1
179 // CHECK: %[[V8:.*]] = load i8*, i8** @g0, align 8 173 // CHECK: %[[V8:.*]] = load ptr, ptr @g0, align 8
180 // CHECK: %[[V9:.*]] = call i8* @llvm.objc.retain(i8* %[[V8]]) 174 // CHECK: %[[V9:.*]] = call ptr @llvm.objc.retain(ptr %[[V8]])
181 // CHECK: store i8* %[[V9]], i8** %[[ARRAYINIT_ELEMENT3]], align 8 175 // CHECK: store ptr %[[V9]], ptr %[[ARRAYINIT_ELEMENT3]], align 8
182 // CHECK: store i1 true, i1* %[[CLEANUP_COND4]], align 1 176 // CHECK: store i1 true, ptr %[[CLEANUP_COND4]], align 1
183 // CHECK: %[[ARRAYDECAY5:.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* %[[_COMPOUNDLITERAL1]], i64 0, i64 0 177 // CHECK: %[[ARRAYDECAY5:.*]] = getelementptr inbounds [2 x ptr], ptr %[[_COMPOUNDLITERAL1]], i64 0, i64 0
184 178
185 // CHECK: %[[COND6:.*]] = phi i8** [ %[[ARRAYDECAY]], %{{.*}} ], [ %[[ARRAYDECAY5]], %{{.*}} ] 179 // CHECK: %[[COND6:.*]] = phi ptr [ %[[ARRAYDECAY]], %{{.*}} ], [ %[[ARRAYDECAY5]], %{{.*}} ]
186 // CHECK: store i8** %[[COND6]], i8*** %[[P]], align 8 180 // CHECK: store ptr %[[COND6]], ptr %[[P]], align 8
187 // CHECK: call void @test2( 181 // CHECK: call void @test2(
188 182
189 // CHECK: %[[ARRAY_BEGIN:.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* %[[_COMPOUNDLITERAL1]], i32 0, i32 0 183 // CHECK: %[[ARRAY_BEGIN:.*]] = getelementptr inbounds [2 x ptr], ptr %[[_COMPOUNDLITERAL1]], i32 0, i32 0
190 // CHECK: %[[V11:.*]] = getelementptr inbounds i8*, i8** %[[ARRAY_BEGIN]], i64 2 184 // CHECK: %[[V11:.*]] = getelementptr inbounds ptr, ptr %[[ARRAY_BEGIN]], i64 2
191 185
192 // CHECK: %[[ARRAYDESTROY_ELEMENTPAST:.*]] = phi i8** [ %[[V11]], %{{.*}} ], [ %[[ARRAYDESTROY_ELEMENT:.*]], %{{.*}} ] 186 // CHECK: %[[ARRAYDESTROY_ELEMENTPAST:.*]] = phi ptr [ %[[V11]], %{{.*}} ], [ %[[ARRAYDESTROY_ELEMENT:.*]], %{{.*}} ]
193 // CHECK: %[[ARRAYDESTROY_ELEMENT]] = getelementptr inbounds i8*, i8** %[[ARRAYDESTROY_ELEMENTPAST]], i64 -1 187 // CHECK: %[[ARRAYDESTROY_ELEMENT]] = getelementptr inbounds ptr, ptr %[[ARRAYDESTROY_ELEMENTPAST]], i64 -1
194 // CHECK: %[[V12:.*]] = load i8*, i8** %[[ARRAYDESTROY_ELEMENT]], align 8 188 // CHECK: %[[V12:.*]] = load ptr, ptr %[[ARRAYDESTROY_ELEMENT]], align 8
195 // CHECK: call void @llvm.objc.release(i8* %[[V12]]) 189 // CHECK: call void @llvm.objc.release(ptr %[[V12]])
196 190
197 // CHECK: %[[ARRAY_BEGIN10:.*]] = getelementptr inbounds [2 x i8*], [2 x i8*]* %[[_COMPOUNDLITERAL]], i32 0, i32 0 191 // CHECK: %[[ARRAY_BEGIN10:.*]] = getelementptr inbounds [2 x ptr], ptr %[[_COMPOUNDLITERAL]], i32 0, i32 0
198 // CHECK: %[[V13:.*]] = getelementptr inbounds i8*, i8** %[[ARRAY_BEGIN10]], i64 2 192 // CHECK: %[[V13:.*]] = getelementptr inbounds ptr, ptr %[[ARRAY_BEGIN10]], i64 2
199 193
200 // CHECK: %[[ARRAYDESTROY_ELEMENTPAST12:.*]] = phi i8** [ %[[V13]], %{{.*}} ], [ %[[ARRAYDESTROY_ELEMENT13:.*]], %{{.*}} ] 194 // CHECK: %[[ARRAYDESTROY_ELEMENTPAST12:.*]] = phi ptr [ %[[V13]], %{{.*}} ], [ %[[ARRAYDESTROY_ELEMENT13:.*]], %{{.*}} ]
201 // CHECK: %[[ARRAYDESTROY_ELEMENT13]] = getelementptr inbounds i8*, i8** %[[ARRAYDESTROY_ELEMENTPAST12]], i64 -1 195 // CHECK: %[[ARRAYDESTROY_ELEMENT13]] = getelementptr inbounds ptr, ptr %[[ARRAYDESTROY_ELEMENTPAST12]], i64 -1
202 // CHECK: %[[V14:.*]] = load i8*, i8** %[[ARRAYDESTROY_ELEMENT13]], align 8 196 // CHECK: %[[V14:.*]] = load ptr, ptr %[[ARRAYDESTROY_ELEMENT13]], align 8
203 // CHECK: call void @llvm.objc.release(i8* %[[V14]]) 197 // CHECK: call void @llvm.objc.release(ptr %[[V14]])
204 } 198 }
205 199
206 // CHECK: attributes [[NUW]] = { nounwind } 200 // CHECK: attributes [[NUW]] = { nounwind }