1 ; RUN: opt < %s -sroa -S | FileCheck %s
2 ; RUN: opt < %s -sroa -force-ssa-updater -S | FileCheck %s
4 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-n8:16:32:64"
6 declare void @llvm.lifetime.start(i64, i8* nocapture)
7 declare void @llvm.lifetime.end(i64, i8* nocapture)
18 %a1.i8 = bitcast i32* %a1 to i8*
19 call void @llvm.lifetime.start(i64 4, i8* %a1.i8)
24 call void @llvm.lifetime.end(i64 4, i8* %a1.i8)
26 %a2.i8 = bitcast float* %a2 to i8*
27 call void @llvm.lifetime.start(i64 4, i8* %a2.i8)
29 store float 0.0, float* %a2
30 %v2 = load float * %a2
31 %v2.int = bitcast float %v2 to i32
32 %sum1 = add i32 %v1, %v2.int
34 call void @llvm.lifetime.end(i64 4, i8* %a2.i8)
45 %X = alloca { i32, float }
46 %Y = getelementptr { i32, float }* %X, i64 0, i32 0
52 define i64 @test2(i64 %X) {
59 %B = bitcast [8 x i8]* %A to i64*
68 define void @test3(i8* %dst, i8* %src) {
72 %a = alloca [300 x i8]
74 ; CHECK: %[[test3_a1:.*]] = alloca [42 x i8]
75 ; CHECK-NEXT: %[[test3_a2:.*]] = alloca [99 x i8]
76 ; CHECK-NEXT: %[[test3_a3:.*]] = alloca [16 x i8]
77 ; CHECK-NEXT: %[[test3_a4:.*]] = alloca [42 x i8]
78 ; CHECK-NEXT: %[[test3_a5:.*]] = alloca [7 x i8]
79 ; CHECK-NEXT: %[[test3_a6:.*]] = alloca [7 x i8]
80 ; CHECK-NEXT: %[[test3_a7:.*]] = alloca [85 x i8]
82 %b = getelementptr [300 x i8]* %a, i64 0, i64 0
83 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b, i8* %src, i32 300, i32 1, i1 false)
84 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a1]], i64 0, i64 0
85 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %src, i32 42
86 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 42
87 ; CHECK-NEXT: %[[test3_r1:.*]] = load i8* %[[gep]]
88 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 43
89 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [99 x i8]* %[[test3_a2]], i64 0, i64 0
90 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 99
91 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 142
92 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 0
93 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 16
94 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 158
95 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a4]], i64 0, i64 0
96 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 42
97 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 200
98 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 0
99 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
100 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 207
101 ; CHECK-NEXT: %[[test3_r2:.*]] = load i8* %[[gep]]
102 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 208
103 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 0
104 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
105 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 215
106 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [85 x i8]* %[[test3_a7]], i64 0, i64 0
107 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 85
109 ; Clobber a single element of the array, this should be promotable.
110 %c = getelementptr [300 x i8]* %a, i64 0, i64 42
113 ; Make a sequence of overlapping stores to the array. These overlap both in
114 ; forward strides and in shrinking accesses.
115 %overlap.1.i8 = getelementptr [300 x i8]* %a, i64 0, i64 142
116 %overlap.2.i8 = getelementptr [300 x i8]* %a, i64 0, i64 143
117 %overlap.3.i8 = getelementptr [300 x i8]* %a, i64 0, i64 144
118 %overlap.4.i8 = getelementptr [300 x i8]* %a, i64 0, i64 145
119 %overlap.5.i8 = getelementptr [300 x i8]* %a, i64 0, i64 146
120 %overlap.6.i8 = getelementptr [300 x i8]* %a, i64 0, i64 147
121 %overlap.7.i8 = getelementptr [300 x i8]* %a, i64 0, i64 148
122 %overlap.8.i8 = getelementptr [300 x i8]* %a, i64 0, i64 149
123 %overlap.9.i8 = getelementptr [300 x i8]* %a, i64 0, i64 150
124 %overlap.1.i16 = bitcast i8* %overlap.1.i8 to i16*
125 %overlap.1.i32 = bitcast i8* %overlap.1.i8 to i32*
126 %overlap.1.i64 = bitcast i8* %overlap.1.i8 to i64*
127 %overlap.2.i64 = bitcast i8* %overlap.2.i8 to i64*
128 %overlap.3.i64 = bitcast i8* %overlap.3.i8 to i64*
129 %overlap.4.i64 = bitcast i8* %overlap.4.i8 to i64*
130 %overlap.5.i64 = bitcast i8* %overlap.5.i8 to i64*
131 %overlap.6.i64 = bitcast i8* %overlap.6.i8 to i64*
132 %overlap.7.i64 = bitcast i8* %overlap.7.i8 to i64*
133 %overlap.8.i64 = bitcast i8* %overlap.8.i8 to i64*
134 %overlap.9.i64 = bitcast i8* %overlap.9.i8 to i64*
135 store i8 1, i8* %overlap.1.i8
136 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 0
137 ; CHECK-NEXT: store i8 1, i8* %[[gep]]
138 store i16 1, i16* %overlap.1.i16
139 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [16 x i8]* %[[test3_a3]] to i16*
140 ; CHECK-NEXT: store i16 1, i16* %[[bitcast]]
141 store i32 1, i32* %overlap.1.i32
142 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [16 x i8]* %[[test3_a3]] to i32*
143 ; CHECK-NEXT: store i32 1, i32* %[[bitcast]]
144 store i64 1, i64* %overlap.1.i64
145 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [16 x i8]* %[[test3_a3]] to i64*
146 ; CHECK-NEXT: store i64 1, i64* %[[bitcast]]
147 store i64 2, i64* %overlap.2.i64
148 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 1
149 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
150 ; CHECK-NEXT: store i64 2, i64* %[[bitcast]]
151 store i64 3, i64* %overlap.3.i64
152 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 2
153 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
154 ; CHECK-NEXT: store i64 3, i64* %[[bitcast]]
155 store i64 4, i64* %overlap.4.i64
156 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 3
157 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
158 ; CHECK-NEXT: store i64 4, i64* %[[bitcast]]
159 store i64 5, i64* %overlap.5.i64
160 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 4
161 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
162 ; CHECK-NEXT: store i64 5, i64* %[[bitcast]]
163 store i64 6, i64* %overlap.6.i64
164 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 5
165 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
166 ; CHECK-NEXT: store i64 6, i64* %[[bitcast]]
167 store i64 7, i64* %overlap.7.i64
168 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 6
169 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
170 ; CHECK-NEXT: store i64 7, i64* %[[bitcast]]
171 store i64 8, i64* %overlap.8.i64
172 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 7
173 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
174 ; CHECK-NEXT: store i64 8, i64* %[[bitcast]]
175 store i64 9, i64* %overlap.9.i64
176 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 8
177 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i64*
178 ; CHECK-NEXT: store i64 9, i64* %[[bitcast]]
180 ; Make two sequences of overlapping stores with more gaps and irregularities.
181 %overlap2.1.0.i8 = getelementptr [300 x i8]* %a, i64 0, i64 200
182 %overlap2.1.1.i8 = getelementptr [300 x i8]* %a, i64 0, i64 201
183 %overlap2.1.2.i8 = getelementptr [300 x i8]* %a, i64 0, i64 202
184 %overlap2.1.3.i8 = getelementptr [300 x i8]* %a, i64 0, i64 203
186 %overlap2.2.0.i8 = getelementptr [300 x i8]* %a, i64 0, i64 208
187 %overlap2.2.1.i8 = getelementptr [300 x i8]* %a, i64 0, i64 209
188 %overlap2.2.2.i8 = getelementptr [300 x i8]* %a, i64 0, i64 210
189 %overlap2.2.3.i8 = getelementptr [300 x i8]* %a, i64 0, i64 211
191 %overlap2.1.0.i16 = bitcast i8* %overlap2.1.0.i8 to i16*
192 %overlap2.1.0.i32 = bitcast i8* %overlap2.1.0.i8 to i32*
193 %overlap2.1.1.i32 = bitcast i8* %overlap2.1.1.i8 to i32*
194 %overlap2.1.2.i32 = bitcast i8* %overlap2.1.2.i8 to i32*
195 %overlap2.1.3.i32 = bitcast i8* %overlap2.1.3.i8 to i32*
196 store i8 1, i8* %overlap2.1.0.i8
197 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 0
198 ; CHECK-NEXT: store i8 1, i8* %[[gep]]
199 store i16 1, i16* %overlap2.1.0.i16
200 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [7 x i8]* %[[test3_a5]] to i16*
201 ; CHECK-NEXT: store i16 1, i16* %[[bitcast]]
202 store i32 1, i32* %overlap2.1.0.i32
203 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [7 x i8]* %[[test3_a5]] to i32*
204 ; CHECK-NEXT: store i32 1, i32* %[[bitcast]]
205 store i32 2, i32* %overlap2.1.1.i32
206 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 1
207 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
208 ; CHECK-NEXT: store i32 2, i32* %[[bitcast]]
209 store i32 3, i32* %overlap2.1.2.i32
210 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 2
211 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
212 ; CHECK-NEXT: store i32 3, i32* %[[bitcast]]
213 store i32 4, i32* %overlap2.1.3.i32
214 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 3
215 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
216 ; CHECK-NEXT: store i32 4, i32* %[[bitcast]]
218 %overlap2.2.0.i32 = bitcast i8* %overlap2.2.0.i8 to i32*
219 %overlap2.2.1.i16 = bitcast i8* %overlap2.2.1.i8 to i16*
220 %overlap2.2.1.i32 = bitcast i8* %overlap2.2.1.i8 to i32*
221 %overlap2.2.2.i32 = bitcast i8* %overlap2.2.2.i8 to i32*
222 %overlap2.2.3.i32 = bitcast i8* %overlap2.2.3.i8 to i32*
223 store i32 1, i32* %overlap2.2.0.i32
224 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast [7 x i8]* %[[test3_a6]] to i32*
225 ; CHECK-NEXT: store i32 1, i32* %[[bitcast]]
226 store i8 1, i8* %overlap2.2.1.i8
227 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 1
228 ; CHECK-NEXT: store i8 1, i8* %[[gep]]
229 store i16 1, i16* %overlap2.2.1.i16
230 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 1
231 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
232 ; CHECK-NEXT: store i16 1, i16* %[[bitcast]]
233 store i32 1, i32* %overlap2.2.1.i32
234 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 1
235 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
236 ; CHECK-NEXT: store i32 1, i32* %[[bitcast]]
237 store i32 3, i32* %overlap2.2.2.i32
238 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 2
239 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
240 ; CHECK-NEXT: store i32 3, i32* %[[bitcast]]
241 store i32 4, i32* %overlap2.2.3.i32
242 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 3
243 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i32*
244 ; CHECK-NEXT: store i32 4, i32* %[[bitcast]]
246 %overlap2.prefix = getelementptr i8* %overlap2.1.1.i8, i64 -4
247 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.prefix, i8* %src, i32 8, i32 1, i1 false)
248 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a4]], i64 0, i64 39
249 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %src, i32 3
250 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 3
251 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 0
252 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 5
254 ; Bridge between the overlapping areas
255 call void @llvm.memset.p0i8.i32(i8* %overlap2.1.2.i8, i8 42, i32 8, i32 1, i1 false)
256 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 2
257 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* %[[gep]], i8 42, i32 5
258 ; ...promoted i8 store...
259 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 0
260 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* %[[gep]], i8 42, i32 2
262 ; Entirely within the second overlap.
263 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.2.1.i8, i8* %src, i32 5, i32 1, i1 false)
264 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 1
265 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep]], i8* %src, i32 5
267 ; Trailing past the second overlap.
268 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %overlap2.2.2.i8, i8* %src, i32 8, i32 1, i1 false)
269 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 2
270 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep]], i8* %src, i32 5
271 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 5
272 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [85 x i8]* %[[test3_a7]], i64 0, i64 0
273 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 3
275 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %b, i32 300, i32 1, i1 false)
276 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a1]], i64 0, i64 0
277 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[gep]], i32 42
278 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 42
279 ; CHECK-NEXT: store i8 0, i8* %[[gep]]
280 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 43
281 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [99 x i8]* %[[test3_a2]], i64 0, i64 0
282 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 99
283 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 142
284 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [16 x i8]* %[[test3_a3]], i64 0, i64 0
285 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 16
286 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 158
287 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [42 x i8]* %[[test3_a4]], i64 0, i64 0
288 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 42
289 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 200
290 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a5]], i64 0, i64 0
291 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
292 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 207
293 ; CHECK-NEXT: store i8 42, i8* %[[gep]]
294 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 208
295 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test3_a6]], i64 0, i64 0
296 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
297 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 215
298 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [85 x i8]* %[[test3_a7]], i64 0, i64 0
299 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 85
304 define void @test4(i8* %dst, i8* %src) {
308 %a = alloca [100 x i8]
310 ; CHECK: %[[test4_a1:.*]] = alloca [20 x i8]
311 ; CHECK-NEXT: %[[test4_a2:.*]] = alloca [7 x i8]
312 ; CHECK-NEXT: %[[test4_a3:.*]] = alloca [10 x i8]
313 ; CHECK-NEXT: %[[test4_a4:.*]] = alloca [7 x i8]
314 ; CHECK-NEXT: %[[test4_a5:.*]] = alloca [7 x i8]
315 ; CHECK-NEXT: %[[test4_a6:.*]] = alloca [40 x i8]
317 %b = getelementptr [100 x i8]* %a, i64 0, i64 0
318 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %b, i8* %src, i32 100, i32 1, i1 false)
319 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [20 x i8]* %[[test4_a1]], i64 0, i64 0
320 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep]], i8* %src, i32 20
321 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 20
322 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
323 ; CHECK-NEXT: %[[test4_r1:.*]] = load i16* %[[bitcast]]
324 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 22
325 ; CHECK-NEXT: %[[test4_r2:.*]] = load i8* %[[gep]]
326 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 23
327 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a2]], i64 0, i64 0
328 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
329 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 30
330 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [10 x i8]* %[[test4_a3]], i64 0, i64 0
331 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 10
332 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 40
333 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
334 ; CHECK-NEXT: %[[test4_r3:.*]] = load i16* %[[bitcast]]
335 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 42
336 ; CHECK-NEXT: %[[test4_r4:.*]] = load i8* %[[gep]]
337 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 43
338 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a4]], i64 0, i64 0
339 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
340 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 50
341 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
342 ; CHECK-NEXT: %[[test4_r5:.*]] = load i16* %[[bitcast]]
343 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %src, i64 52
344 ; CHECK-NEXT: %[[test4_r6:.*]] = load i8* %[[gep]]
345 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 53
346 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a5]], i64 0, i64 0
347 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
348 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds i8* %src, i64 60
349 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [40 x i8]* %[[test4_a6]], i64 0, i64 0
350 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 40
352 %a.src.1 = getelementptr [100 x i8]* %a, i64 0, i64 20
353 %a.dst.1 = getelementptr [100 x i8]* %a, i64 0, i64 40
354 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.dst.1, i8* %a.src.1, i32 10, i32 1, i1 false)
355 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a4]], i64 0, i64 0
356 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a2]], i64 0, i64 0
357 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
359 ; Clobber a single element of the array, this should be promotable, and be deleted.
360 %c = getelementptr [100 x i8]* %a, i64 0, i64 42
363 %a.src.2 = getelementptr [100 x i8]* %a, i64 0, i64 50
364 call void @llvm.memmove.p0i8.p0i8.i32(i8* %a.dst.1, i8* %a.src.2, i32 10, i32 1, i1 false)
365 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a4]], i64 0, i64 0
366 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a5]], i64 0, i64 0
367 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
369 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %b, i32 100, i32 1, i1 false)
370 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds [20 x i8]* %[[test4_a1]], i64 0, i64 0
371 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[gep]], i32 20
372 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 20
373 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
374 ; CHECK-NEXT: store i16 %[[test4_r1]], i16* %[[bitcast]]
375 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 22
376 ; CHECK-NEXT: store i8 %[[test4_r2]], i8* %[[gep]]
377 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 23
378 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a2]], i64 0, i64 0
379 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
380 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 30
381 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [10 x i8]* %[[test4_a3]], i64 0, i64 0
382 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 10
383 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 40
384 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
385 ; CHECK-NEXT: store i16 %[[test4_r5]], i16* %[[bitcast]]
386 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 42
387 ; CHECK-NEXT: store i8 %[[test4_r6]], i8* %[[gep]]
388 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 43
389 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a4]], i64 0, i64 0
390 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
391 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 50
392 ; CHECK-NEXT: %[[bitcast:.*]] = bitcast i8* %[[gep]] to i16*
393 ; CHECK-NEXT: store i16 %[[test4_r5]], i16* %[[bitcast]]
394 ; CHECK-NEXT: %[[gep:.*]] = getelementptr inbounds i8* %dst, i64 52
395 ; CHECK-NEXT: store i8 %[[test4_r6]], i8* %[[gep]]
396 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 53
397 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [7 x i8]* %[[test4_a5]], i64 0, i64 0
398 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 7
399 ; CHECK-NEXT: %[[gep_dst:.*]] = getelementptr inbounds i8* %dst, i64 60
400 ; CHECK-NEXT: %[[gep_src:.*]] = getelementptr inbounds [40 x i8]* %[[test4_a6]], i64 0, i64 0
401 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[gep_dst]], i8* %[[gep_src]], i32 40
406 declare void @llvm.memcpy.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
407 declare void @llvm.memmove.p0i8.p0i8.i32(i8* nocapture, i8* nocapture, i32, i32, i1) nounwind
408 declare void @llvm.memset.p0i8.i32(i8* nocapture, i8, i32, i32, i1) nounwind
410 define i16 @test5() {
412 ; CHECK-NOT: alloca float
413 ; CHECK: %[[cast:.*]] = bitcast float 0.0{{.*}} to i32
414 ; CHECK-NEXT: %[[shr:.*]] = lshr i32 %[[cast]], 16
415 ; CHECK-NEXT: %[[trunc:.*]] = trunc i32 %[[shr]] to i16
416 ; CHECK-NEXT: ret i16 %[[trunc]]
420 %fptr = bitcast [4 x i8]* %a to float*
421 store float 0.0, float* %fptr
422 %ptr = getelementptr [4 x i8]* %a, i32 0, i32 2
423 %iptr = bitcast i8* %ptr to i16*
424 %val = load i16* %iptr
428 define i32 @test6() {
431 ; CHECK-NEXT: store volatile i32
432 ; CHECK-NEXT: load i32*
433 ; CHECK-NEXT: ret i32
437 %ptr = getelementptr [4 x i8]* %a, i32 0, i32 0
438 call void @llvm.memset.p0i8.i32(i8* %ptr, i8 42, i32 4, i32 1, i1 true)
439 %iptr = bitcast i8* %ptr to i32*
440 %val = load i32* %iptr
444 define void @test7(i8* %src, i8* %dst) {
447 ; CHECK-NEXT: bitcast i8* %src to i32*
448 ; CHECK-NEXT: load volatile i32*
449 ; CHECK-NEXT: store volatile i32
450 ; CHECK-NEXT: bitcast i8* %dst to i32*
451 ; CHECK-NEXT: load volatile i32*
452 ; CHECK-NEXT: store volatile i32
457 %ptr = getelementptr [4 x i8]* %a, i32 0, i32 0
458 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 true)
459 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 true)
464 %S1 = type { i32, i32, [16 x i8] }
465 %S2 = type { %S1*, %S2* }
467 define %S2 @test8(%S2* %s2) {
473 %s2.next.ptr = getelementptr %S2* %s2, i64 0, i32 1
474 %s2.next = load %S2** %s2.next.ptr
475 ; CHECK: %[[gep:.*]] = getelementptr %S2* %s2, i64 0, i32 1
476 ; CHECK-NEXT: %[[next:.*]] = load %S2** %[[gep]]
478 %s2.next.s1.ptr = getelementptr %S2* %s2.next, i64 0, i32 0
479 %s2.next.s1 = load %S1** %s2.next.s1.ptr
480 %new.s1.ptr = getelementptr %S2* %new, i64 0, i32 0
481 store %S1* %s2.next.s1, %S1** %new.s1.ptr
482 %s2.next.next.ptr = getelementptr %S2* %s2.next, i64 0, i32 1
483 %s2.next.next = load %S2** %s2.next.next.ptr
484 %new.next.ptr = getelementptr %S2* %new, i64 0, i32 1
485 store %S2* %s2.next.next, %S2** %new.next.ptr
486 ; CHECK-NEXT: %[[gep:.*]] = getelementptr %S2* %[[next]], i64 0, i32 0
487 ; CHECK-NEXT: %[[next_s1:.*]] = load %S1** %[[gep]]
488 ; CHECK-NEXT: %[[gep:.*]] = getelementptr %S2* %[[next]], i64 0, i32 1
489 ; CHECK-NEXT: %[[next_next:.*]] = load %S2** %[[gep]]
491 %new.s1 = load %S1** %new.s1.ptr
492 %result1 = insertvalue %S2 undef, %S1* %new.s1, 0
493 ; CHECK-NEXT: %[[result1:.*]] = insertvalue %S2 undef, %S1* %[[next_s1]], 0
494 %new.next = load %S2** %new.next.ptr
495 %result2 = insertvalue %S2 %result1, %S2* %new.next, 1
496 ; CHECK-NEXT: %[[result2:.*]] = insertvalue %S2 %[[result1]], %S2* %[[next_next]], 1
498 ; CHECK-NEXT: ret %S2 %[[result2]]
501 define i64 @test9() {
502 ; Ensure we can handle loads off the end of an alloca even when wrapped in
503 ; weird bit casts and types. The result is undef, but this shouldn't crash
507 ; CHECK: ret i64 undef
510 %a = alloca { [3 x i8] }
511 %gep1 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 0
512 store i8 0, i8* %gep1, align 1
513 %gep2 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 1
514 store i8 0, i8* %gep2, align 1
515 %gep3 = getelementptr inbounds { [3 x i8] }* %a, i32 0, i32 0, i32 2
516 store i8 26, i8* %gep3, align 1
517 %cast = bitcast { [3 x i8] }* %a to { i64 }*
518 %elt = getelementptr inbounds { i64 }* %cast, i32 0, i32 0
519 %result = load i64* %elt
523 define %S2* @test10() {
525 ; CHECK-NOT: alloca %S2*
526 ; CHECK: ret %S2* null
530 %ptr = getelementptr [8 x i8]* %a, i32 0, i32 0
531 call void @llvm.memset.p0i8.i32(i8* %ptr, i8 0, i32 8, i32 1, i1 false)
532 %s2ptrptr = bitcast i8* %ptr to %S2**
533 %s2ptr = load %S2** %s2ptrptr
537 define i32 @test11() {
544 br i1 undef, label %good, label %bad
547 %Y = getelementptr i32* %X, i64 0
553 %Y2 = getelementptr i32* %X, i64 1
554 store i32 0, i32* %Y2
559 define i8 @test12() {
560 ; We fully promote these to the i24 load or store size, resulting in just masks
561 ; and other operations that instcombine will fold, but no alloca.
570 %a0ptr = getelementptr [3 x i8]* %a, i64 0, i32 0
571 store i8 0, i8* %a0ptr
572 %a1ptr = getelementptr [3 x i8]* %a, i64 0, i32 1
573 store i8 0, i8* %a1ptr
574 %a2ptr = getelementptr [3 x i8]* %a, i64 0, i32 2
575 store i8 0, i8* %a2ptr
576 %aiptr = bitcast [3 x i8]* %a to i24*
577 %ai = load i24* %aiptr
580 ; CHECK: %[[ext2:.*]] = zext i8 0 to i24
581 ; CHECK-NEXT: %[[shift2:.*]] = shl i24 %[[ext2]], 16
582 ; CHECK-NEXT: %[[mask2:.*]] = and i24 undef, 65535
583 ; CHECK-NEXT: %[[insert2:.*]] = or i24 %[[mask2]], %[[shift2]]
584 ; CHECK-NEXT: %[[ext1:.*]] = zext i8 0 to i24
585 ; CHECK-NEXT: %[[shift1:.*]] = shl i24 %[[ext1]], 8
586 ; CHECK-NEXT: %[[mask1:.*]] = and i24 %[[insert2]], -65281
587 ; CHECK-NEXT: %[[insert1:.*]] = or i24 %[[mask1]], %[[shift1]]
588 ; CHECK-NEXT: %[[ext0:.*]] = zext i8 0 to i24
589 ; CHECK-NEXT: %[[mask0:.*]] = and i24 %[[insert1]], -256
590 ; CHECK-NEXT: %[[insert0:.*]] = or i24 %[[mask0]], %[[ext0]]
592 %biptr = bitcast [3 x i8]* %b to i24*
593 store i24 %ai, i24* %biptr
594 %b0ptr = getelementptr [3 x i8]* %b, i64 0, i32 0
595 %b0 = load i8* %b0ptr
596 %b1ptr = getelementptr [3 x i8]* %b, i64 0, i32 1
597 %b1 = load i8* %b1ptr
598 %b2ptr = getelementptr [3 x i8]* %b, i64 0, i32 2
599 %b2 = load i8* %b2ptr
602 ; CHECK: %[[trunc0:.*]] = trunc i24 %[[insert0]] to i8
603 ; CHECK-NEXT: %[[shift1:.*]] = lshr i24 %[[insert0]], 8
604 ; CHECK-NEXT: %[[trunc1:.*]] = trunc i24 %[[shift1]] to i8
605 ; CHECK-NEXT: %[[shift2:.*]] = lshr i24 %[[insert0]], 16
606 ; CHECK-NEXT: %[[trunc2:.*]] = trunc i24 %[[shift2]] to i8
608 %bsum0 = add i8 %b0, %b1
609 %bsum1 = add i8 %bsum0, %b2
611 ; CHECK: %[[sum0:.*]] = add i8 %[[trunc0]], %[[trunc1]]
612 ; CHECK-NEXT: %[[sum1:.*]] = add i8 %[[sum0]], %[[trunc2]]
613 ; CHECK-NEXT: ret i8 %[[sum1]]
616 define i32 @test13() {
617 ; Ensure we don't crash and handle undefined loads that straddle the end of the
620 ; CHECK: %[[ret:.*]] = zext i16 undef to i32
621 ; CHECK: ret i32 %[[ret]]
625 %b0ptr = getelementptr [3 x i8]* %a, i64 0, i32 0
626 store i8 0, i8* %b0ptr
627 %b1ptr = getelementptr [3 x i8]* %a, i64 0, i32 1
628 store i8 0, i8* %b1ptr
629 %b2ptr = getelementptr [3 x i8]* %a, i64 0, i32 2
630 store i8 0, i8* %b2ptr
631 %iptrcast = bitcast [3 x i8]* %a to i16*
632 %iptrgep = getelementptr i16* %iptrcast, i64 1
633 %i = load i16* %iptrgep
634 %ret = zext i16 %i to i32
638 %test14.struct = type { [3 x i32] }
640 define void @test14(...) nounwind uwtable {
641 ; This is a strange case where we split allocas into promotable partitions, but
642 ; also gain enough data to prove they must be dead allocas due to GEPs that walk
643 ; across two adjacent allocas. Test that we don't try to promote or otherwise
644 ; do bad things to these dead allocas, they should just be removed.
647 ; CHECK-NEXT: ret void
650 %a = alloca %test14.struct
651 %p = alloca %test14.struct*
652 %0 = bitcast %test14.struct* %a to i8*
653 %1 = getelementptr i8* %0, i64 12
654 %2 = bitcast i8* %1 to %test14.struct*
655 %3 = getelementptr inbounds %test14.struct* %2, i32 0, i32 0
656 %4 = getelementptr inbounds %test14.struct* %a, i32 0, i32 0
657 %5 = bitcast [3 x i32]* %3 to i32*
658 %6 = bitcast [3 x i32]* %4 to i32*
659 %7 = load i32* %6, align 4
660 store i32 %7, i32* %5, align 4
661 %8 = getelementptr inbounds i32* %5, i32 1
662 %9 = getelementptr inbounds i32* %6, i32 1
663 %10 = load i32* %9, align 4
664 store i32 %10, i32* %8, align 4
665 %11 = getelementptr inbounds i32* %5, i32 2
666 %12 = getelementptr inbounds i32* %6, i32 2
667 %13 = load i32* %12, align 4
668 store i32 %13, i32* %11, align 4
672 define i32 @test15(i1 %flag) nounwind uwtable {
673 ; Ensure that when there are dead instructions using an alloca that are not
674 ; loads or stores we still delete them during partitioning and rewriting.
675 ; Otherwise we'll go to promote them while thy still have unpromotable uses.
678 ; CHECK-NEXT: br label %loop
680 ; CHECK-NEXT: br label %loop
690 %dead3 = phi i8* [ %gep3, %loop ], [ null, %entry ]
692 store i64 1879048192, i64* %l0, align 8
693 %bc0 = bitcast i64* %l0 to i8*
694 %gep0 = getelementptr i8* %bc0, i64 3
695 %dead0 = bitcast i8* %gep0 to i64*
697 store i64 1879048192, i64* %l1, align 8
698 %bc1 = bitcast i64* %l1 to i8*
699 %gep1 = getelementptr i8* %bc1, i64 3
700 %dead1 = getelementptr i8* %gep1, i64 1
702 store i64 1879048192, i64* %l2, align 8
703 %bc2 = bitcast i64* %l2 to i8*
704 %gep2.1 = getelementptr i8* %bc2, i64 1
705 %gep2.2 = getelementptr i8* %bc2, i64 3
706 ; Note that this select should get visited multiple times due to using two
707 ; different GEPs off the same alloca. We should only delete it once.
708 %dead2 = select i1 %flag, i8* %gep2.1, i8* %gep2.2
710 store i64 1879048192, i64* %l3, align 8
711 %bc3 = bitcast i64* %l3 to i8*
712 %gep3 = getelementptr i8* %bc3, i64 3
717 define void @test16(i8* %src, i8* %dst) {
718 ; Ensure that we can promote an alloca of [3 x i8] to an i24 SSA value.
721 ; CHECK: %[[srccast:.*]] = bitcast i8* %src to i24*
722 ; CHECK-NEXT: load i24* %[[srccast]]
723 ; CHECK-NEXT: %[[dstcast:.*]] = bitcast i8* %dst to i24*
724 ; CHECK-NEXT: store i24 0, i24* %[[dstcast]]
725 ; CHECK-NEXT: ret void
729 %ptr = getelementptr [3 x i8]* %a, i32 0, i32 0
730 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 false)
731 %cast = bitcast i8* %ptr to i24*
732 store i24 0, i24* %cast
733 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 false)
737 define void @test17(i8* %src, i8* %dst) {
738 ; Ensure that we can rewrite unpromotable memcpys which extend past the end of
741 ; CHECK: %[[a:.*]] = alloca [3 x i8]
742 ; CHECK-NEXT: %[[ptr:.*]] = getelementptr [3 x i8]* %[[a]], i32 0, i32 0
743 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[ptr]], i8* %src,
744 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[ptr]],
745 ; CHECK-NEXT: ret void
749 %ptr = getelementptr [3 x i8]* %a, i32 0, i32 0
750 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 4, i32 1, i1 true)
751 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 4, i32 1, i1 true)
755 define void @test18(i8* %src, i8* %dst, i32 %size) {
756 ; Preserve transfer instrinsics with a variable size, even if they overlap with
757 ; fixed size operations. Further, continue to split and promote allocas preceding
758 ; the variable sized intrinsic.
760 ; CHECK: %[[a:.*]] = alloca [34 x i8]
761 ; CHECK: %[[srcgep1:.*]] = getelementptr inbounds i8* %src, i64 4
762 ; CHECK-NEXT: %[[srccast1:.*]] = bitcast i8* %[[srcgep1]] to i32*
763 ; CHECK-NEXT: %[[srcload:.*]] = load i32* %[[srccast1]]
764 ; CHECK-NEXT: %[[agep1:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
765 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %[[agep1]], i8* %src, i32 %size,
766 ; CHECK-NEXT: %[[agep2:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
767 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i8* %[[agep2]], i8 42, i32 %size,
768 ; CHECK-NEXT: %[[dstcast1:.*]] = bitcast i8* %dst to i32*
769 ; CHECK-NEXT: store i32 42, i32* %[[dstcast1]]
770 ; CHECK-NEXT: %[[dstgep1:.*]] = getelementptr inbounds i8* %dst, i64 4
771 ; CHECK-NEXT: %[[dstcast2:.*]] = bitcast i8* %[[dstgep1]] to i32*
772 ; CHECK-NEXT: store i32 %[[srcload]], i32* %[[dstcast2]]
773 ; CHECK-NEXT: %[[agep3:.*]] = getelementptr inbounds [34 x i8]* %[[a]], i64 0, i64 0
774 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %[[agep3]], i32 %size,
775 ; CHECK-NEXT: ret void
778 %a = alloca [42 x i8]
779 %ptr = getelementptr [42 x i8]* %a, i32 0, i32 0
780 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr, i8* %src, i32 8, i32 1, i1 false)
781 %ptr2 = getelementptr [42 x i8]* %a, i32 0, i32 8
782 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %ptr2, i8* %src, i32 %size, i32 1, i1 false)
783 call void @llvm.memset.p0i8.i32(i8* %ptr2, i8 42, i32 %size, i32 1, i1 false)
784 %cast = bitcast i8* %ptr to i32*
785 store i32 42, i32* %cast
786 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr, i32 8, i32 1, i1 false)
787 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %ptr2, i32 %size, i32 1, i1 false)
791 %opaque = type opaque
793 define i32 @test19(%opaque* %x) {
794 ; This input will cause us to try to compute a natural GEP when rewriting
795 ; pointers in such a way that we try to GEP through the opaque type. Previously,
796 ; a check for an unsized type was missing and this crashed. Ensure it behaves
800 ; CHECK: ret i32 undef
803 %a = alloca { i64, i8* }
804 %cast1 = bitcast %opaque* %x to i8*
805 %cast2 = bitcast { i64, i8* }* %a to i8*
806 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast2, i8* %cast1, i32 16, i32 1, i1 false)
807 %gep = getelementptr inbounds { i64, i8* }* %a, i32 0, i32 0
808 %val = load i64* %gep
812 define i32 @test20() {
813 ; Ensure we can track negative offsets (before the beginning of the alloca) and
814 ; negative relative offsets from offsets starting past the end of the alloca.
817 ; CHECK: %[[sum1:.*]] = add i32 1, 2
818 ; CHECK: %[[sum2:.*]] = add i32 %[[sum1]], 3
819 ; CHECK: ret i32 %[[sum2]]
822 %a = alloca [3 x i32]
823 %gep1 = getelementptr [3 x i32]* %a, i32 0, i32 0
824 store i32 1, i32* %gep1
825 %gep2.1 = getelementptr [3 x i32]* %a, i32 0, i32 -2
826 %gep2.2 = getelementptr i32* %gep2.1, i32 3
827 store i32 2, i32* %gep2.2
828 %gep3.1 = getelementptr [3 x i32]* %a, i32 0, i32 14
829 %gep3.2 = getelementptr i32* %gep3.1, i32 -12
830 store i32 3, i32* %gep3.2
832 %load1 = load i32* %gep1
833 %load2 = load i32* %gep2.2
834 %load3 = load i32* %gep3.2
835 %sum1 = add i32 %load1, %load2
836 %sum2 = add i32 %sum1, %load3
840 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
842 define i8 @test21() {
843 ; Test allocations and offsets which border on overflow of the int64_t used
844 ; internally. This is really awkward to really test as LLVM doesn't really
845 ; support such extreme constructs cleanly.
848 ; CHECK: or i8 -1, -1
851 %a = alloca [2305843009213693951 x i8]
852 %gep0 = getelementptr [2305843009213693951 x i8]* %a, i64 0, i64 2305843009213693949
853 store i8 255, i8* %gep0
854 %gep1 = getelementptr [2305843009213693951 x i8]* %a, i64 0, i64 -9223372036854775807
855 %gep2 = getelementptr i8* %gep1, i64 -1
856 call void @llvm.memset.p0i8.i64(i8* %gep2, i8 0, i64 18446744073709551615, i32 1, i1 false)
857 %gep3 = getelementptr i8* %gep1, i64 9223372036854775807
858 %gep4 = getelementptr i8* %gep3, i64 9223372036854775807
859 %gep5 = getelementptr i8* %gep4, i64 -6917529027641081857
860 store i8 255, i8* %gep5
861 %cast1 = bitcast i8* %gep4 to i32*
862 store i32 0, i32* %cast1
863 %load = load i8* %gep0
864 %gep6 = getelementptr i8* %gep0, i32 1
865 %load2 = load i8* %gep6
866 %result = or i8 %load, %load2
870 %PR13916.struct = type { i8 }
872 define void @PR13916.1() {
873 ; Ensure that we handle overlapping memcpy intrinsics correctly, especially in
874 ; the case where there is a directly identical value for both source and dest.
881 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a, i8* %a, i32 1, i32 1, i1 false)
886 define void @PR13916.2() {
887 ; Check whether we continue to handle them correctly when they start off with
888 ; different pointer value chains, but during rewriting we coalesce them into the
895 %a = alloca %PR13916.struct, align 1
896 br i1 undef, label %if.then, label %if.end
899 %tmp0 = bitcast %PR13916.struct* %a to i8*
900 %tmp1 = bitcast %PR13916.struct* %a to i8*
901 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %tmp0, i8* %tmp1, i32 1, i32 1, i1 false)
905 %gep = getelementptr %PR13916.struct* %a, i32 0, i32 0
906 %tmp2 = load i8* %gep
910 define void @PR13990() {
911 ; Ensure we can handle cases where processing one alloca causes the other
912 ; alloca to become dead and get deleted. This might crash or fail under
913 ; Valgrind if we regress.
922 br i1 undef, label %bb1, label %bb2
925 store i8* undef, i8** %tmp2
926 br i1 undef, label %bb2, label %bb3
929 %tmp50 = select i1 undef, i8** %tmp2, i8** %tmp1
930 br i1 undef, label %bb3, label %bb4
939 define double @PR13969(double %x) {
940 ; Check that we detect when promotion will un-escape an alloca and iterate to
941 ; re-try running SROA over that alloca. Without that, the two allocas that are
942 ; stored into a dead alloca don't get rewritten and promoted.
951 store double %x, double* %a
952 store double* %c, double** %b
953 store double* %a, double** %b
954 store double %x, double* %c
955 %ret = load double* %a
960 ; CHECK: ret double %x
963 %PR14034.struct = type { { {} }, i32, %PR14034.list }
964 %PR14034.list = type { %PR14034.list*, %PR14034.list* }
966 define void @PR14034() {
967 ; This test case tries to form GEPs into the empty leading struct members, and
968 ; subsequently crashed (under valgrind) before we fixed the PR. The important
969 ; thing is to handle empty structs gracefully.
973 %a = alloca %PR14034.struct
974 %list = getelementptr %PR14034.struct* %a, i32 0, i32 2
975 %prev = getelementptr %PR14034.list* %list, i32 0, i32 1
976 store %PR14034.list* undef, %PR14034.list** %prev
977 %cast0 = bitcast %PR14034.struct* undef to i8*
978 %cast1 = bitcast %PR14034.struct* %a to i8*
979 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast0, i8* %cast1, i32 12, i32 0, i1 false)
983 define i32 @test22(i32 %x) {
984 ; Test that SROA and promotion is not confused by a grab bax mixture of pointer
985 ; types involving wrapper aggregates and zero-length aggregate members.
989 %a1 = alloca { { [1 x { i32 }] } }
990 %a2 = alloca { {}, { float }, [0 x i8] }
991 %a3 = alloca { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }
994 %wrap1 = insertvalue [1 x { i32 }] undef, i32 %x, 0, 0
995 %gep1 = getelementptr { { [1 x { i32 }] } }* %a1, i32 0, i32 0, i32 0
996 store [1 x { i32 }] %wrap1, [1 x { i32 }]* %gep1
998 %gep2 = getelementptr { { [1 x { i32 }] } }* %a1, i32 0, i32 0
999 %ptrcast1 = bitcast { [1 x { i32 }] }* %gep2 to { [1 x { float }] }*
1000 %load1 = load { [1 x { float }] }* %ptrcast1
1001 %unwrap1 = extractvalue { [1 x { float }] } %load1, 0, 0
1003 %wrap2 = insertvalue { {}, { float }, [0 x i8] } undef, { float } %unwrap1, 1
1004 store { {}, { float }, [0 x i8] } %wrap2, { {}, { float }, [0 x i8] }* %a2
1006 %gep3 = getelementptr { {}, { float }, [0 x i8] }* %a2, i32 0, i32 1, i32 0
1007 %ptrcast2 = bitcast float* %gep3 to <4 x i8>*
1008 %load3 = load <4 x i8>* %ptrcast2
1009 %valcast1 = bitcast <4 x i8> %load3 to i32
1011 %wrap3 = insertvalue [1 x [1 x i32]] undef, i32 %valcast1, 0, 0
1012 %wrap4 = insertvalue { [1 x [1 x i32]], {} } undef, [1 x [1 x i32]] %wrap3, 0
1013 %gep4 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }* %a3, i32 0, i32 1
1014 %ptrcast3 = bitcast { [0 x double], [1 x [1 x <4 x i8>]], {} }* %gep4 to { [1 x [1 x i32]], {} }*
1015 store { [1 x [1 x i32]], {} } %wrap4, { [1 x [1 x i32]], {} }* %ptrcast3
1017 %gep5 = getelementptr { [0 x i8], { [0 x double], [1 x [1 x <4 x i8>]], {} }, { { {} } } }* %a3, i32 0, i32 1, i32 1, i32 0
1018 %ptrcast4 = bitcast [1 x <4 x i8>]* %gep5 to { {}, float, {} }*
1019 %load4 = load { {}, float, {} }* %ptrcast4
1020 %unwrap2 = extractvalue { {}, float, {} } %load4, 1
1021 %valcast2 = bitcast float %unwrap2 to i32
1027 define void @PR14059.1(double* %d) {
1028 ; In PR14059 a peculiar construct was identified as something that is used
1029 ; pervasively in ARM's ABI-calling-convention lowering: the passing of a struct
1030 ; of doubles via an array of i32 in order to place the data into integer
1031 ; registers. This in turn was missed as an optimization by SROA due to the
1032 ; partial loads and stores of integers to the double alloca we were trying to
1033 ; form and promote. The solution is to widen the integer operations to be
1034 ; whole-alloca operations, and perform the appropriate bitcasting on the
1035 ; *values* rather than the pointers. When this works, partial reads and writes
1036 ; via integers can be promoted away.
1042 %X.sroa.0.i = alloca double, align 8
1043 %0 = bitcast double* %X.sroa.0.i to i8*
1044 call void @llvm.lifetime.start(i64 -1, i8* %0)
1046 ; Store to the low 32-bits...
1047 %X.sroa.0.0.cast2.i = bitcast double* %X.sroa.0.i to i32*
1048 store i32 0, i32* %X.sroa.0.0.cast2.i, align 8
1050 ; Also use a memset to the middle 32-bits for fun.
1051 %X.sroa.0.2.raw_idx2.i = getelementptr inbounds i8* %0, i32 2
1052 call void @llvm.memset.p0i8.i64(i8* %X.sroa.0.2.raw_idx2.i, i8 0, i64 4, i32 1, i1 false)
1054 ; Or a memset of the whole thing.
1055 call void @llvm.memset.p0i8.i64(i8* %0, i8 0, i64 8, i32 1, i1 false)
1057 ; Write to the high 32-bits with a memcpy.
1058 %X.sroa.0.4.raw_idx4.i = getelementptr inbounds i8* %0, i32 4
1059 %d.raw = bitcast double* %d to i8*
1060 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %X.sroa.0.4.raw_idx4.i, i8* %d.raw, i32 4, i32 1, i1 false)
1062 ; Store to the high 32-bits...
1063 %X.sroa.0.4.cast5.i = bitcast i8* %X.sroa.0.4.raw_idx4.i to i32*
1064 store i32 1072693248, i32* %X.sroa.0.4.cast5.i, align 4
1066 ; Do the actual math...
1067 %X.sroa.0.0.load1.i = load double* %X.sroa.0.i, align 8
1068 %accum.real.i = load double* %d, align 8
1069 %add.r.i = fadd double %accum.real.i, %X.sroa.0.0.load1.i
1070 store double %add.r.i, double* %d, align 8
1071 call void @llvm.lifetime.end(i64 -1, i8* %0)
1075 define i64 @PR14059.2({ float, float }* %phi) {
1076 ; Check that SROA can split up alloca-wide integer loads and stores where the
1077 ; underlying alloca has smaller components that are accessed independently. This
1078 ; shows up particularly with ABI lowering patterns coming out of Clang that rely
1079 ; on the particular register placement of a single large integer return value.
1083 %retval = alloca { float, float }, align 4
1086 %0 = bitcast { float, float }* %retval to i64*
1087 store i64 0, i64* %0
1090 %phi.realp = getelementptr inbounds { float, float }* %phi, i32 0, i32 0
1091 %phi.real = load float* %phi.realp
1092 %phi.imagp = getelementptr inbounds { float, float }* %phi, i32 0, i32 1
1093 %phi.imag = load float* %phi.imagp
1094 ; CHECK: %[[realp:.*]] = getelementptr inbounds { float, float }* %phi, i32 0, i32 0
1095 ; CHECK-NEXT: %[[real:.*]] = load float* %[[realp]]
1096 ; CHECK-NEXT: %[[imagp:.*]] = getelementptr inbounds { float, float }* %phi, i32 0, i32 1
1097 ; CHECK-NEXT: %[[imag:.*]] = load float* %[[imagp]]
1099 %real = getelementptr inbounds { float, float }* %retval, i32 0, i32 0
1100 %imag = getelementptr inbounds { float, float }* %retval, i32 0, i32 1
1101 store float %phi.real, float* %real
1102 store float %phi.imag, float* %imag
1103 ; CHECK-NEXT: %[[real_convert:.*]] = bitcast float %[[real]] to i32
1104 ; CHECK-NEXT: %[[imag_convert:.*]] = bitcast float %[[imag]] to i32
1105 ; CHECK-NEXT: %[[imag_ext:.*]] = zext i32 %[[imag_convert]] to i64
1106 ; CHECK-NEXT: %[[imag_shift:.*]] = shl i64 %[[imag_ext]], 32
1107 ; CHECK-NEXT: %[[imag_mask:.*]] = and i64 undef, 4294967295
1108 ; CHECK-NEXT: %[[imag_insert:.*]] = or i64 %[[imag_mask]], %[[imag_shift]]
1109 ; CHECK-NEXT: %[[real_ext:.*]] = zext i32 %[[real_convert]] to i64
1110 ; CHECK-NEXT: %[[real_mask:.*]] = and i64 %[[imag_insert]], -4294967296
1111 ; CHECK-NEXT: %[[real_insert:.*]] = or i64 %[[real_mask]], %[[real_ext]]
1113 %1 = load i64* %0, align 1
1115 ; CHECK-NEXT: ret i64 %[[real_insert]]
1118 define void @PR14105({ [16 x i8] }* %ptr) {
1119 ; Ensure that when rewriting the GEP index '-1' for this alloca we preserve is
1120 ; sign as negative. We use a volatile memcpy to ensure promotion never actually
1125 %a = alloca { [16 x i8] }, align 8
1126 ; CHECK: alloca [16 x i8], align 8
1128 %gep = getelementptr inbounds { [16 x i8] }* %ptr, i64 -1
1129 ; CHECK-NEXT: getelementptr inbounds { [16 x i8] }* %ptr, i64 -1, i32 0, i64 0
1131 %cast1 = bitcast { [16 x i8 ] }* %gep to i8*
1132 %cast2 = bitcast { [16 x i8 ] }* %a to i8*
1133 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %cast1, i8* %cast2, i32 16, i32 8, i1 true)
1138 define void @PR14465() {
1139 ; Ensure that we don't crash when analyzing a alloca larger than the maximum
1140 ; integer type width (MAX_INT_BITS) supported by llvm (1048576*32 > (1<<23)-1).
1143 %stack = alloca [1048576 x i32], align 16
1144 ; CHECK: alloca [1048576 x i32]
1145 %cast = bitcast [1048576 x i32]* %stack to i8*
1146 call void @llvm.memset.p0i8.i64(i8* %cast, i8 -2, i64 4194304, i32 16, i1 false)
1151 define void @PR14548(i1 %x) {
1152 ; Handle a mixture of i1 and i8 loads and stores to allocas. This particular
1153 ; pattern caused crashes and invalid output in the PR, and its nature will
1154 ; trigger a mixture in several permutations as we resolve each alloca
1156 ; Note that we don't do a particularly good *job* of handling these mixtures,
1157 ; but the hope is that this is very rare.
1161 %a = alloca <{ i1 }>, align 8
1162 %b = alloca <{ i1 }>, align 8
1163 ; Nothing of interest is simplified here.
1167 %b.i1 = bitcast <{ i1 }>* %b to i1*
1168 store i1 %x, i1* %b.i1, align 8
1169 %b.i8 = bitcast <{ i1 }>* %b to i8*
1170 %foo = load i8* %b.i8, align 1
1172 %a.i8 = bitcast <{ i1 }>* %a to i8*
1173 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %a.i8, i8* %b.i8, i32 1, i32 1, i1 false) nounwind
1174 %bar = load i8* %a.i8, align 1
1175 %a.i1 = getelementptr inbounds <{ i1 }>* %a, i32 0, i32 0
1176 %baz = load i1* %a.i1, align 1
1180 define <3 x i8> @PR14572.1(i32 %x) {
1181 ; Ensure that a split integer store which is wider than the type size of the
1182 ; alloca (relying on the alloc size padding) doesn't trigger an assert.
1186 %a = alloca <3 x i8>, align 4
1189 %cast = bitcast <3 x i8>* %a to i32*
1190 store i32 %x, i32* %cast, align 1
1191 %y = load <3 x i8>* %a, align 4
1193 ; CHECK: ret <3 x i8>
1196 define i32 @PR14572.2(<3 x i8> %x) {
1197 ; Ensure that a split integer load which is wider than the type size of the
1198 ; alloca (relying on the alloc size padding) doesn't trigger an assert.
1202 %a = alloca <3 x i8>, align 4
1205 store <3 x i8> %x, <3 x i8>* %a, align 1
1206 %cast = bitcast <3 x i8>* %a to i32*
1207 %y = load i32* %cast, align 4
1212 define i32 @PR14601(i32 %x) {
1213 ; Don't try to form a promotable integer alloca when there is a variable length
1221 %a.i8 = bitcast i32* %a to i8*
1222 call void @llvm.memset.p0i8.i32(i8* %a.i8, i8 0, i32 %x, i32 1, i1 false)