[sanitizer] Improve FreeBSD ASLR detection
[llvm-project.git] / llvm / test / Transforms / DeadStoreElimination / noop-stores.ll
blob7a8d09b049d2636b8803bc53b257835769fcdb9c
1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
2 ; RUN: opt < %s -basic-aa -dse -S | FileCheck %s
3 ; RUN: opt < %s -aa-pipeline=basic-aa -passes='dse,verify<memoryssa>' -S | FileCheck %s
4 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
6 declare void @memset_pattern16(i8*, i8*, i64)
8 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i1) nounwind
9 declare void @llvm.memset.element.unordered.atomic.p0i8.i64(i8* nocapture, i8, i64, i32) nounwind
10 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i1) nounwind
11 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32) nounwind
12 declare void @llvm.init.trampoline(i8*, i8*, i8*)
14 ; **** Noop load->store tests **************************************************
16 ; We CAN optimize volatile loads.
17 define void @test_load_volatile(i32* %Q) {
18 ; CHECK-LABEL: @test_load_volatile(
19 ; CHECK-NEXT:    [[A:%.*]] = load volatile i32, i32* [[Q:%.*]], align 4
20 ; CHECK-NEXT:    ret void
22   %a = load volatile i32, i32* %Q
23   store i32 %a, i32* %Q
24   ret void
27 ; We can NOT optimize volatile stores.
28 define void @test_store_volatile(i32* %Q) {
29 ; CHECK-LABEL: @test_store_volatile(
30 ; CHECK-NEXT:    [[A:%.*]] = load i32, i32* [[Q:%.*]], align 4
31 ; CHECK-NEXT:    store volatile i32 [[A]], i32* [[Q]], align 4
32 ; CHECK-NEXT:    ret void
34   %a = load i32, i32* %Q
35   store volatile i32 %a, i32* %Q
36   ret void
39 ; PR2599 - load -> store to same address.
40 define void @test12({ i32, i32 }* %x) nounwind  {
41 ; CHECK-LABEL: @test12(
42 ; CHECK-NEXT:    [[TEMP7:%.*]] = getelementptr { i32, i32 }, { i32, i32 }* [[X:%.*]], i32 0, i32 1
43 ; CHECK-NEXT:    [[TEMP8:%.*]] = load i32, i32* [[TEMP7]], align 4
44 ; CHECK-NEXT:    [[TEMP17:%.*]] = sub i32 0, [[TEMP8]]
45 ; CHECK-NEXT:    store i32 [[TEMP17]], i32* [[TEMP7]], align 4
46 ; CHECK-NEXT:    ret void
48   %temp4 = getelementptr { i32, i32 }, { i32, i32 }* %x, i32 0, i32 0
49   %temp5 = load i32, i32* %temp4, align 4
50   %temp7 = getelementptr { i32, i32 }, { i32, i32 }* %x, i32 0, i32 1
51   %temp8 = load i32, i32* %temp7, align 4
52   %temp17 = sub i32 0, %temp8
53   store i32 %temp5, i32* %temp4, align 4
54   store i32 %temp17, i32* %temp7, align 4
55   ret void
58 ; Remove redundant store if loaded value is in another block.
59 define i32 @test26(i1 %c, i32* %p) {
60 ; CHECK-LABEL: @test26(
61 ; CHECK-NEXT:  entry:
62 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
63 ; CHECK:       bb1:
64 ; CHECK-NEXT:    br label [[BB3:%.*]]
65 ; CHECK:       bb2:
66 ; CHECK-NEXT:    br label [[BB3]]
67 ; CHECK:       bb3:
68 ; CHECK-NEXT:    ret i32 0
70 entry:
71   %v = load i32, i32* %p, align 4
72   br i1 %c, label %bb1, label %bb2
73 bb1:
74   br label %bb3
75 bb2:
76   store i32 %v, i32* %p, align 4
77   br label %bb3
78 bb3:
79   ret i32 0
82 ; Remove redundant store if loaded value is in another block.
83 define i32 @test27(i1 %c, i32* %p) {
84 ; CHECK-LABEL: @test27(
85 ; CHECK-NEXT:  entry:
86 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB1:%.*]], label [[BB2:%.*]]
87 ; CHECK:       bb1:
88 ; CHECK-NEXT:    br label [[BB3:%.*]]
89 ; CHECK:       bb2:
90 ; CHECK-NEXT:    br label [[BB3]]
91 ; CHECK:       bb3:
92 ; CHECK-NEXT:    ret i32 0
94 entry:
95   %v = load i32, i32* %p, align 4
96   br i1 %c, label %bb1, label %bb2
97 bb1:
98   br label %bb3
99 bb2:
100   br label %bb3
101 bb3:
102   store i32 %v, i32* %p, align 4
103   ret i32 0
106 ; Remove redundant store if loaded value is in another block inside a loop.
107 define i32 @test31(i1 %c, i32* %p, i32 %i) {
108 ; CHECK-LABEL: @test31(
109 ; CHECK-NEXT:  entry:
110 ; CHECK-NEXT:    br label [[BB1:%.*]]
111 ; CHECK:       bb1:
112 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB1]], label [[BB2:%.*]]
113 ; CHECK:       bb2:
114 ; CHECK-NEXT:    ret i32 0
116 entry:
117   %v = load i32, i32* %p, align 4
118   br label %bb1
119 bb1:
120   store i32 %v, i32* %p, align 4
121   br i1 %c, label %bb1, label %bb2
122 bb2:
123   ret i32 0
126 ; Don't remove "redundant" store if %p is possibly stored to.
127 define i32 @test46(i1 %c, i32* %p, i32* %p2, i32 %i) {
128 ; CHECK-LABEL: @test46(
129 ; CHECK-NEXT:  entry:
130 ; CHECK-NEXT:    [[V:%.*]] = load i32, i32* [[P:%.*]], align 4
131 ; CHECK-NEXT:    br label [[BB1:%.*]]
132 ; CHECK:       bb1:
133 ; CHECK-NEXT:    store i32 [[V]], i32* [[P]], align 4
134 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB1]], label [[BB2:%.*]]
135 ; CHECK:       bb2:
136 ; CHECK-NEXT:    store i32 0, i32* [[P2:%.*]], align 4
137 ; CHECK-NEXT:    br i1 [[C]], label [[BB3:%.*]], label [[BB1]]
138 ; CHECK:       bb3:
139 ; CHECK-NEXT:    ret i32 0
141 entry:
142   %v = load i32, i32* %p, align 4
143   br label %bb1
144 bb1:
145   store i32 %v, i32* %p, align 4
146   br i1 %c, label %bb1, label %bb2
147 bb2:
148   store i32 0, i32* %p2, align 4
149   br i1 %c, label %bb3, label %bb1
150 bb3:
151   ret i32 0
154 declare void @unknown_func()
156 ; Remove redundant store, which is in the lame loop as the load.
157 define i32 @test33(i1 %c, i32* %p, i32 %i) {
158 ; CHECK-LABEL: @test33(
159 ; CHECK-NEXT:  entry:
160 ; CHECK-NEXT:    br label [[BB1:%.*]]
161 ; CHECK:       bb1:
162 ; CHECK-NEXT:    br label [[BB2:%.*]]
163 ; CHECK:       bb2:
164 ; CHECK-NEXT:    call void @unknown_func()
165 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB1]], label [[BB3:%.*]]
166 ; CHECK:       bb3:
167 ; CHECK-NEXT:    ret i32 0
169 entry:
170   br label %bb1
171 bb1:
172   %v = load i32, i32* %p, align 4
173   br label %bb2
174 bb2:
175   store i32 %v, i32* %p, align 4
176   ; Might read and overwrite value at %p, but doesn't matter.
177   call void @unknown_func()
178   br i1 %c, label %bb1, label %bb3
179 bb3:
180   ret i32 0
183 declare void @unkown_write(i32*)
185 ; We can't remove the "noop" store around an unkown write.
186 define void @test43(i32* %Q) {
187 ; CHECK-LABEL: @test43(
188 ; CHECK-NEXT:    [[A:%.*]] = load i32, i32* [[Q:%.*]], align 4
189 ; CHECK-NEXT:    call void @unkown_write(i32* [[Q]])
190 ; CHECK-NEXT:    store i32 [[A]], i32* [[Q]], align 4
191 ; CHECK-NEXT:    ret void
193   %a = load i32, i32* %Q
194   call void @unkown_write(i32* %Q)
195   store i32 %a, i32* %Q
196   ret void
199 ; We CAN remove it when the unkown write comes AFTER.
200 define void @test44(i32* %Q) {
201 ; CHECK-LABEL: @test44(
202 ; CHECK-NEXT:    call void @unkown_write(i32* [[Q:%.*]])
203 ; CHECK-NEXT:    ret void
205   %a = load i32, i32* %Q
206   store i32 %a, i32* %Q
207   call void @unkown_write(i32* %Q)
208   ret void
211 define void @test45(i32* %Q) {
212 ; CHECK-LABEL: @test45(
213 ; CHECK-NEXT:    ret void
215   %a = load i32, i32* %Q
216   store i32 10, i32* %Q
217   store i32 %a, i32* %Q
218   ret void
221 define i32 @test48(i1 %c, i32* %p) {
222 ; CHECK-LABEL: @test48(
223 ; CHECK-NEXT:  entry:
224 ; CHECK-NEXT:    [[V:%.*]] = load i32, i32* [[P:%.*]], align 4
225 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB0:%.*]], label [[BB0_0:%.*]]
226 ; CHECK:       bb0:
227 ; CHECK-NEXT:    store i32 0, i32* [[P]], align 4
228 ; CHECK-NEXT:    br i1 [[C]], label [[BB1:%.*]], label [[BB2:%.*]]
229 ; CHECK:       bb0.0:
230 ; CHECK-NEXT:    br label [[BB1]]
231 ; CHECK:       bb1:
232 ; CHECK-NEXT:    store i32 [[V]], i32* [[P]], align 4
233 ; CHECK-NEXT:    br i1 [[C]], label [[BB2]], label [[BB0]]
234 ; CHECK:       bb2:
235 ; CHECK-NEXT:    ret i32 0
237 entry:
238   %v = load i32, i32* %p, align 4
239   br i1 %c, label %bb0, label %bb0.0
241 bb0:
242   store i32 0, i32* %p
243   br i1 %c, label %bb1, label %bb2
245 bb0.0:
246   br label %bb1
248 bb1:
249   store i32 %v, i32* %p, align 4
250   br i1 %c, label %bb2, label %bb0
251 bb2:
252   ret i32 0
255 define i32 @test47(i1 %c, i32* %p, i32 %i) {
256 ; CHECK-LABEL: @test47(
257 ; CHECK-NEXT:  entry:
258 ; CHECK-NEXT:    br label [[BB1:%.*]]
259 ; CHECK:       bb1:
260 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB1]], label [[BB2:%.*]]
261 ; CHECK:       bb2:
262 ; CHECK-NEXT:    br i1 [[C]], label [[BB3:%.*]], label [[BB1]]
263 ; CHECK:       bb3:
264 ; CHECK-NEXT:    ret i32 0
266 entry:
267   %v = load i32, i32* %p, align 4
268   br label %bb1
269 bb1:
270   store i32 %v, i32* %p, align 4
271   br i1 %c, label %bb1, label %bb2
272 bb2:
273   store i32 %v, i32* %p, align 4
274   br i1 %c, label %bb3, label %bb1
275 bb3:
276   ret i32 0
279 ; Test case from PR47887.
280 define void @test_noalias_store_between_load_and_store(i32* noalias %x, i32* noalias %y) {
281 ; CHECK-LABEL: @test_noalias_store_between_load_and_store(
282 ; CHECK-NEXT:  entry:
283 ; CHECK-NEXT:    store i32 0, i32* [[Y:%.*]], align 4
284 ; CHECK-NEXT:    ret void
286 entry:
287   %lv = load i32, i32* %x, align 4
288   store i32 0, i32* %y, align 4
289   store i32 %lv, i32* %x, align 4
290   ret void
293 ; Test case from PR47887. Currently we eliminate the dead `store i32 %inc, i32* %x`,
294 ; but not the no-op `store i32 %lv, i32* %x`. That is because no-op stores are
295 ; eliminated before dead stores for the same def.
296 define void @test_noalias_store_between_load_and_store_elimin_order(i32* noalias %x, i32* noalias %y) {
297 ; CHECK-LABEL: @test_noalias_store_between_load_and_store_elimin_order(
298 ; CHECK-NEXT:  entry:
299 ; CHECK-NEXT:    store i32 0, i32* [[Y:%.*]], align 4
300 ; CHECK-NEXT:    ret void
302 entry:
303   %lv = load i32, i32* %x, align 4
304   %inc = add nsw i32 %lv, 1
305   store i32 %inc, i32* %x, align 4
306   store i32 0, i32* %y, align 4
307   store i32 %lv, i32* %x, align 4
308   ret void
311 declare noalias i8* @malloc(i64)
312 declare noalias i8* @_Znwm(i64)
313 declare void @clobber_memory(float*)
315 ; based on pr25892_lite
316 define i8* @zero_memset_after_malloc(i64 %size) {
317 ; CHECK-LABEL: @zero_memset_after_malloc(
318 ; CHECK-NEXT:    [[CALL:%.*]] = call i8* @calloc(i64 1, i64 [[SIZE:%.*]])
319 ; CHECK-NEXT:    ret i8* [[CALL]]
321   %call = call i8* @malloc(i64 %size) inaccessiblememonly
322   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 %size, i1 false)
323   ret i8* %call
326 ; based on pr25892_lite
327 define i8* @zero_memset_after_malloc_with_intermediate_clobbering(i64 %size) {
328 ; CHECK-LABEL: @zero_memset_after_malloc_with_intermediate_clobbering(
329 ; CHECK-NEXT:    [[CALL:%.*]] = call i8* @malloc(i64 [[SIZE:%.*]])
330 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i8* [[CALL]] to float*
331 ; CHECK-NEXT:    call void @clobber_memory(float* [[BC]])
332 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 0, i64 [[SIZE]], i1 false)
333 ; CHECK-NEXT:    ret i8* [[CALL]]
335   %call = call i8* @malloc(i64 %size) inaccessiblememonly
336   %bc = bitcast i8* %call to float*
337   call void @clobber_memory(float* %bc)
338   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 %size, i1 false)
339   ret i8* %call
342 ; based on pr25892_lite
343 define i8* @zero_memset_after_malloc_with_different_sizes(i64 %size) {
344 ; CHECK-LABEL: @zero_memset_after_malloc_with_different_sizes(
345 ; CHECK-NEXT:    [[CALL:%.*]] = call i8* @malloc(i64 [[SIZE:%.*]])
346 ; CHECK-NEXT:    [[SIZE2:%.*]] = add nsw i64 [[SIZE]], -1
347 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 0, i64 [[SIZE2]], i1 false)
348 ; CHECK-NEXT:    ret i8* [[CALL]]
350   %call = call i8* @malloc(i64 %size) inaccessiblememonly
351   %size2 = add nsw i64 %size, -1
352   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 %size2, i1 false)
353   ret i8* %call
356 ; based on pr25892_lite
357 define i8* @zero_memset_after_new(i64 %size) {
358 ; CHECK-LABEL: @zero_memset_after_new(
359 ; CHECK-NEXT:    [[CALL:%.*]] = call i8* @_Znwm(i64 [[SIZE:%.*]])
360 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 0, i64 [[SIZE]], i1 false)
361 ; CHECK-NEXT:    ret i8* [[CALL]]
363   %call = call i8* @_Znwm(i64 %size)
364   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 %size, i1 false)
365   ret i8* %call
368 ; This should not create a calloc and should not crash the compiler.
369 define i8* @notmalloc_memset(i64 %size, i8*(i64)* %notmalloc) {
370 ; CHECK-LABEL: @notmalloc_memset(
371 ; CHECK-NEXT:    [[CALL1:%.*]] = call i8* [[NOTMALLOC:%.*]](i64 [[SIZE:%.*]])
372 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL1]], i8 0, i64 [[SIZE]], i1 false)
373 ; CHECK-NEXT:    ret i8* [[CALL1]]
375   %call1 = call i8* %notmalloc(i64 %size)
376   call void @llvm.memset.p0i8.i64(i8* %call1, i8 0, i64 %size, i1 false)
377   ret i8* %call1
380 ; This should not create recursive call to calloc.
381 define i8* @calloc(i64 %nmemb, i64 %size) {
382 ; CHECK-LABEL: @calloc(
383 ; CHECK:       entry:
384 ; CHECK-NEXT:    [[MUL:%.*]] = mul i64 [[SIZE:%.*]], [[NMEMB:%.*]]
385 ; CHECK-NEXT:    [[CALL:%.*]] = tail call noalias align 16 i8* @malloc(i64 [[MUL]])
386 ; CHECK-NEXT:    [[TOBOOL_NOT:%.*]] = icmp eq i8* [[CALL]], null
387 ; CHECK-NEXT:    br i1 [[TOBOOL_NOT]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
388 ; CHECK:       if.then:
389 ; CHECK-NEXT:    tail call void @llvm.memset.p0i8.i64(i8* nonnull align 16 [[CALL]], i8 0, i64 [[MUL]], i1 false)
390 ; CHECK-NEXT:    br label [[IF_END]]
391 ; CHECK:       if.end:
392 ; CHECK-NEXT:    ret i8* [[CALL]]
394 entry:
395   %mul = mul i64 %size, %nmemb
396   %call = tail call noalias align 16 i8* @malloc(i64 %mul)
397   %tobool.not = icmp eq i8* %call, null
398   br i1 %tobool.not, label %if.end, label %if.then
400 if.then:                                          ; preds = %entry
401   tail call void @llvm.memset.p0i8.i64(i8* nonnull align 16 %call, i8 0, i64 %mul, i1 false)
402   br label %if.end
404 if.end:                                           ; preds = %if.then, %entry
405   ret i8* %call
408 define float* @pr25892(i64 %size) {
409 ; CHECK-LABEL: @pr25892(
410 ; CHECK:       entry:
411 ; CHECK-NEXT:    [[CALL:%.*]] = call i8* @calloc(i64 1, i64 [[SIZE:%.*]])
412 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8* [[CALL]], null
413 ; CHECK-NEXT:    br i1 [[CMP]], label [[CLEANUP:%.*]], label [[IF_END:%.*]]
414 ; CHECK:       if.end:
415 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i8* [[CALL]] to float*
416 ; CHECK-NEXT:    br label [[CLEANUP]]
417 ; CHECK:       cleanup:
418 ; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi float* [ [[BC]], [[IF_END]] ], [ null, [[ENTRY:%.*]] ]
419 ; CHECK-NEXT:    ret float* [[RETVAL_0]]
421 entry:
422   %call = call i8* @malloc(i64 %size) inaccessiblememonly
423   %cmp = icmp eq i8* %call, null
424   br i1 %cmp, label %cleanup, label %if.end
425 if.end:
426   %bc = bitcast i8* %call to float*
427   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 %size, i1 false)
428   br label %cleanup
429 cleanup:
430   %retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ]
431   ret float* %retval.0
434 define float* @pr25892_with_extra_store(i64 %size) {
435 ; CHECK-LABEL: @pr25892_with_extra_store(
436 ; CHECK:       entry:
437 ; CHECK-NEXT:    [[CALL:%.*]] = call i8* @calloc(i64 1, i64 [[SIZE:%.*]])
438 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i8* [[CALL]], null
439 ; CHECK-NEXT:    br i1 [[CMP]], label [[CLEANUP:%.*]], label [[IF_END:%.*]]
440 ; CHECK:       if.end:
441 ; CHECK-NEXT:    [[BC:%.*]] = bitcast i8* [[CALL]] to float*
442 ; CHECK-NEXT:    br label [[CLEANUP]]
443 ; CHECK:       cleanup:
444 ; CHECK-NEXT:    [[RETVAL_0:%.*]] = phi float* [ [[BC]], [[IF_END]] ], [ null, [[ENTRY:%.*]] ]
445 ; CHECK-NEXT:    ret float* [[RETVAL_0]]
447 entry:
448   %call = call i8* @malloc(i64 %size) inaccessiblememonly
449   %cmp = icmp eq i8* %call, null
450   br i1 %cmp, label %cleanup, label %if.end
451 if.end:
452   %bc = bitcast i8* %call to float*
453   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 %size, i1 false)
454   store i8 0, i8* %call, align 1
455   br label %cleanup
456 cleanup:
457   %retval.0 = phi float* [ %bc, %if.end ], [ null, %entry ]
458   ret float* %retval.0
461 ; This should not create a calloc
462 define i8* @malloc_with_no_nointer_null_check(i64 %0, i32 %1) {
463 ; CHECK-LABEL: @malloc_with_no_nointer_null_check
464 ; CHECK:       entry:
465 ; CHECK-NEXT:    [[CALL:%.*]] = call i8* @malloc(i64 [[TMP0:%.*]])
466 ; CHECK-NEXT:    [[A:%.*]] = and i32 [[TMP1:%.*]], 32
467 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[A]], 0
468 ; CHECK-NEXT:    br i1 [[CMP]], label [[CLEANUP:%.*]], label [[IF_END:%.*]]
469 ; CHECK:       if.end:
470 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 0, i64 [[TMP0]], i1 false)
471 ; CHECK-NEXT:    br label [[CLEANUP]]
472 ; CHECK:       cleanup:
473 ; CHECK-NEXT:    ret i8* [[CALL]]
475 entry:
476   %call = call i8* @malloc(i64 %0) inaccessiblememonly
477   %a = and i32 %1, 32
478   %cmp = icmp eq i32 %a, 0
479   br i1 %cmp, label %cleanup, label %if.end
480 if.end:
481   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 %0, i1 false)
482   br label %cleanup
483 cleanup:
484   ret i8* %call
487 ; PR50143
488 define i8* @store_zero_after_calloc_inaccessiblememonly() {
489 ; CHECK-LABEL: @store_zero_after_calloc_inaccessiblememonly(
490 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 1, i64 10) #[[ATTR6:[0-9]+]]
491 ; CHECK-NEXT:    store i8 0, i8* [[CALL]], align 1
492 ; CHECK-NEXT:    ret i8* [[CALL]]
494   %call = tail call i8* @calloc(i64 1, i64 10)  inaccessiblememonly
495   store i8 0, i8* %call
496   ret i8* %call
499 define i8* @zero_memset_after_calloc()  {
500 ; CHECK-LABEL: @zero_memset_after_calloc(
501 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
502 ; CHECK-NEXT:    ret i8* [[CALL]]
504   %call = tail call i8* @calloc(i64 10000, i64 4)
505   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 40000, i1 false)
506   ret i8* %call
509 define i8* @volatile_zero_memset_after_calloc()  {
510 ; CHECK-LABEL: @volatile_zero_memset_after_calloc(
511 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
512 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 0, i64 40000, i1 true)
513 ; CHECK-NEXT:    ret i8* [[CALL]]
515   %call = tail call i8* @calloc(i64 10000, i64 4)
516   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 40000, i1 true)
517   ret i8* %call
520 define i8* @zero_memset_and_store_after_calloc(i8 %v)  {
521 ; CHECK-LABEL: @zero_memset_and_store_after_calloc(
522 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
523 ; CHECK-NEXT:    ret i8* [[CALL]]
525   %call = tail call i8* @calloc(i64 10000, i64 4)
526   store i8 %v, i8* %call
527   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 40000, i1 false)
528   ret i8* %call
531 define i8* @partial_zero_memset_after_calloc() {
532 ; CHECK-LABEL: @partial_zero_memset_after_calloc(
533 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
534 ; CHECK-NEXT:    ret i8* [[CALL]]
536   %call = tail call i8* @calloc(i64 10000, i64 4)
537   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 20, i1 false)
538   ret i8* %call
541 define i8* @partial_zero_memset_and_store_after_calloc(i8 %v)  {
542 ; CHECK-LABEL: @partial_zero_memset_and_store_after_calloc(
543 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
544 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i8, i8* [[CALL]], i64 30
545 ; CHECK-NEXT:    store i8 [[V:%.*]], i8* [[GEP]], align 1
546 ; CHECK-NEXT:    ret i8* [[CALL]]
548   %call = tail call i8* @calloc(i64 10000, i64 4)
549   %gep = getelementptr inbounds i8, i8* %call, i64 30
550   store i8 %v, i8* %gep
551   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 20, i1 false)
552   ret i8* %call
555 define i8* @zero_memset_and_store_with_dyn_index_after_calloc(i8 %v, i64 %idx)  {
556 ; CHECK-LABEL: @zero_memset_and_store_with_dyn_index_after_calloc(
557 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
558 ; CHECK-NEXT:    ret i8* [[CALL]]
560   %call = tail call i8* @calloc(i64 10000, i64 4)
561   %gep = getelementptr inbounds i8, i8* %call, i64 %idx
562   store i8 %v, i8* %gep
563   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 40000, i1 false)
564   ret i8* %call
567 define i8* @partial_zero_memset_and_store_with_dyn_index_after_calloc(i8 %v, i64 %idx)  {
568 ; CHECK-LABEL: @partial_zero_memset_and_store_with_dyn_index_after_calloc(
569 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
570 ; CHECK-NEXT:    [[GEP:%.*]] = getelementptr inbounds i8, i8* [[CALL]], i64 [[IDX:%.*]]
571 ; CHECK-NEXT:    store i8 [[V:%.*]], i8* [[GEP]], align 1
572 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 0, i64 20, i1 false)
573 ; CHECK-NEXT:    ret i8* [[CALL]]
575   %call = tail call i8* @calloc(i64 10000, i64 4)
576   %gep = getelementptr inbounds i8, i8* %call, i64 %idx
577   store i8 %v, i8* %gep
578   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 20, i1 false)
579   ret i8* %call
582 define i8* @zero_memset_after_calloc_inaccessiblememonly()  {
583 ; CHECK-LABEL: @zero_memset_after_calloc_inaccessiblememonly(
584 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4) #[[ATTR6]]
585 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 0, i64 40000, i1 false)
586 ; CHECK-NEXT:    ret i8* [[CALL]]
588   %call = tail call i8* @calloc(i64 10000, i64 4) inaccessiblememonly
589   call void @llvm.memset.p0i8.i64(i8* %call, i8 0, i64 40000, i1 false)
590   ret i8* %call
593 define i8* @cst_nonzero_memset_after_calloc() {
594 ; CHECK-LABEL: @cst_nonzero_memset_after_calloc(
595 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
596 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 1, i64 40000, i1 false)
597 ; CHECK-NEXT:    ret i8* [[CALL]]
599   %call = tail call i8* @calloc(i64 10000, i64 4)
600   call void @llvm.memset.p0i8.i64(i8* %call, i8 1, i64 40000, i1 false)
601   ret i8* %call
604 define i8* @nonzero_memset_after_calloc(i8 %v) {
605 ; CHECK-LABEL: @nonzero_memset_after_calloc(
606 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
607 ; CHECK-NEXT:    call void @llvm.memset.p0i8.i64(i8* [[CALL]], i8 [[V:%.*]], i64 40000, i1 false)
608 ; CHECK-NEXT:    ret i8* [[CALL]]
610   %call = tail call i8* @calloc(i64 10000, i64 4)
611   call void @llvm.memset.p0i8.i64(i8* %call, i8 %v, i64 40000, i1 false)
612   ret i8* %call
615 ; PR11896
616 ; The first memset is dead, because calloc provides zero-filled memory.
617 ; TODO: This could be replaced with a call to malloc + memset_pattern16.
618 define i8* @memset_pattern16_after_calloc(i8* %pat) {
619 ; CHECK-LABEL: @memset_pattern16_after_calloc(
620 ; CHECK-NEXT:    [[CALL:%.*]] = tail call i8* @calloc(i64 10000, i64 4)
621 ; CHECK-NEXT:    call void @memset_pattern16(i8* [[CALL]], i8* [[PAT:%.*]], i64 40000)
622 ; CHECK-NEXT:    ret i8* [[CALL]]
624   %call = tail call i8* @calloc(i64 10000, i64 4) #1
625   call void @llvm.memset.p0i8.i64(i8* align 4 %call, i8 0, i64 40000, i1 false)
626   call void @memset_pattern16(i8* %call, i8* %pat, i64 40000) #1
627   ret i8* %call
630 @n = global i32 0, align 4
631 @a = external global i32, align 4
632 @b = external global i32*, align 8
634 ; GCC calloc-1.c test case should create calloc
635 define i8* @test_malloc_memset_to_calloc(i64* %0) {
636 ; CHECK-LABEL: @test_malloc_memset_to_calloc(
637 ; CHECK:       entry:
638 ; CHECK-NEXT:    [[TMP1:%.*]] = load i32, i32* @n, align 4
639 ; CHECK-NEXT:    [[TMP2:%.*]] = sext i32 [[TMP1]] to i64
640 ; CHECK-NEXT:    [[CALLOC:%.*]] = call i8* @calloc(i64 1, i64 [[TMP2]])
641 ; CHECK-NEXT:    [[TMP3:%.*]] = load i64, i64* [[TMP0:%.*]], align 8
642 ; CHECK-NEXT:    [[TMP4:%.*]] = add nsw i64 [[TMP3]], 1
643 ; CHECK-NEXT:    store i64 [[TMP4]], i64* [[TMP0]], align 8
644 ; CHECK-NEXT:    [[TMP5:%.*]] = icmp eq i8* [[CALLOC]], null
645 ; CHECK-NEXT:    br i1 [[TMP5]], label [[IF_END:%.*]], label [[IF_THEN:%.*]]
646 ; CHECK:       if.then:                                          ; preds = %entry
647 ; CHECK-NEXT:    [[TMP6:%.*]] = add nsw i64 [[TMP3]], 2
648 ; CHECK-NEXT:    store i64 [[TMP6]], i64* [[TMP0]], align 8
649 ; CHECK-NEXT:    store i32 2, i32* @a, align 4
650 ; CHECK-NEXT:    [[TMP7:%.*]] = load i32*, i32** @b, align 8
651 ; CHECK-NEXT:    store i32 3, i32* [[TMP7]], align 4
652 ; CHECK-NEXT:    br label [[IF_END]]
653 ; CHECK:       if.end:                                           ; preds = %if.then, %entry
654 ; CHECK-NEXT:    ret i8* [[CALLOC]]
656 entry:
657   %1 = load i32, i32* @n, align 4
658   %2 = sext i32 %1 to i64
659   %3 = tail call i8* @malloc(i64 %2) inaccessiblememonly
660   %4 = load i64, i64* %0, align 8
661   %5 = add nsw i64 %4, 1
662   store i64 %5, i64* %0, align 8
663   %6 = icmp eq i8* %3, null
664   br i1 %6, label %if.end, label %if.then
666 if.then:
667   %7 = add nsw i64 %4, 2
668   store i64 %7, i64* %0, align 8
669   store i32 2, i32* @a, align 4
670   tail call void @llvm.memset.p0i8.i64(i8* align 4 %3, i8 0, i64 %2, i1 false)
671   %8 = load i32*, i32** @b, align 8
672   store i32 3, i32* %8, align 4
673   br label %if.end
675 if.end:
676   ret i8* %3