1 ; RUN: opt < %s -default-data-layout="e-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-n8:16:32" -basicaa -gvn -S -die | FileCheck %s
2 ; RUN: opt < %s -default-data-layout="E-p:32:32:32-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:64:64-n32" -basicaa -gvn -S -die | FileCheck %s
5 define i32 @test0(i32 %V, i32* %P) {
10 ; CHECK-LABEL: @test0(
15 ;;===----------------------------------------------------------------------===;;
17 ;;===----------------------------------------------------------------------===;;
20 define i8 @crash0({i32, i32} %A, {i32, i32}* %P) {
21 store {i32, i32} %A, {i32, i32}* %P
22 %X = bitcast {i32, i32}* %P to i8*
27 ;; No PR filed, crashed in CaptureTracker.
28 declare void @helper()
29 define void @crash1() {
30 tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* undef, i8* undef, i64 undef, i32 1, i1 false) nounwind
31 %tmp = load i8* bitcast (void ()* @helper to i8*)
32 %x = icmp eq i8 %tmp, 15
37 ;;===----------------------------------------------------------------------===;;
38 ;; Store -> Load and Load -> Load forwarding where src and dst are different
39 ;; types, but where the base pointer is a must alias.
40 ;;===----------------------------------------------------------------------===;;
42 ;; i32 -> f32 forwarding.
43 define float @coerce_mustalias1(i32 %V, i32* %P) {
46 %P2 = bitcast i32* %P to float*
50 ; CHECK-LABEL: @coerce_mustalias1(
55 ;; i32* -> float forwarding.
56 define float @coerce_mustalias2(i32* %V, i32** %P) {
57 store i32* %V, i32** %P
59 %P2 = bitcast i32** %P to float*
63 ; CHECK-LABEL: @coerce_mustalias2(
68 ;; float -> i32* forwarding.
69 define i32* @coerce_mustalias3(float %V, float* %P) {
70 store float %V, float* %P
72 %P2 = bitcast float* %P to i32**
76 ; CHECK-LABEL: @coerce_mustalias3(
81 ;; i32 -> f32 load forwarding.
82 define float @coerce_mustalias4(i32* %P, i1 %cond) {
85 %P2 = bitcast i32* %P to float*
87 br i1 %cond, label %T, label %F
92 %X = bitcast i32 %A to float
95 ; CHECK-LABEL: @coerce_mustalias4(
96 ; CHECK: %A = load i32* %P
102 ;; i32 -> i8 forwarding
103 define i8 @coerce_mustalias5(i32 %V, i32* %P) {
104 store i32 %V, i32* %P
106 %P2 = bitcast i32* %P to i8*
110 ; CHECK-LABEL: @coerce_mustalias5(
115 ;; i64 -> float forwarding
116 define float @coerce_mustalias6(i64 %V, i64* %P) {
117 store i64 %V, i64* %P
119 %P2 = bitcast i64* %P to float*
123 ; CHECK-LABEL: @coerce_mustalias6(
128 ;; i64 -> i8* (32-bit) forwarding
129 define i8* @coerce_mustalias7(i64 %V, i64* %P) {
130 store i64 %V, i64* %P
132 %P2 = bitcast i64* %P to i8**
136 ; CHECK-LABEL: @coerce_mustalias7(
141 ; memset -> i16 forwarding.
142 define signext i16 @memset_to_i16_local(i16* %A) nounwind ssp {
144 %conv = bitcast i16* %A to i8*
145 tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 1, i64 200, i32 1, i1 false)
146 %arrayidx = getelementptr inbounds i16* %A, i64 42
147 %tmp2 = load i16* %arrayidx
149 ; CHECK-LABEL: @memset_to_i16_local(
154 ; memset -> float forwarding.
155 define float @memset_to_float_local(float* %A, i8 %Val) nounwind ssp {
157 %conv = bitcast float* %A to i8* ; <i8*> [#uses=1]
158 tail call void @llvm.memset.p0i8.i64(i8* %conv, i8 %Val, i64 400, i32 1, i1 false)
159 %arrayidx = getelementptr inbounds float* %A, i64 42 ; <float*> [#uses=1]
160 %tmp2 = load float* %arrayidx ; <float> [#uses=1]
162 ; CHECK-LABEL: @memset_to_float_local(
169 ; CHECK-NEXT: bitcast
170 ; CHECK-NEXT: ret float
173 ;; non-local memset -> i16 load forwarding.
174 define i16 @memset_to_i16_nonlocal0(i16* %P, i1 %cond) {
175 %P3 = bitcast i16* %P to i8*
176 br i1 %cond, label %T, label %F
178 tail call void @llvm.memset.p0i8.i64(i8* %P3, i8 1, i64 400, i32 1, i1 false)
182 tail call void @llvm.memset.p0i8.i64(i8* %P3, i8 2, i64 400, i32 1, i1 false)
186 %P2 = getelementptr i16* %P, i32 4
190 ; CHECK-LABEL: @memset_to_i16_nonlocal0(
192 ; CHECK-NEXT: %A = phi i16 [ 514, %F ], [ 257, %T ]
197 @GCst = constant {i32, float, i32 } { i32 42, float 14., i32 97 }
198 @GCst_as1 = addrspace(1) constant {i32, float, i32 } { i32 42, float 14., i32 97 }
200 ; memset -> float forwarding.
201 define float @memcpy_to_float_local(float* %A) nounwind ssp {
203 %conv = bitcast float* %A to i8* ; <i8*> [#uses=1]
204 tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %conv, i8* bitcast ({i32, float, i32 }* @GCst to i8*), i64 12, i32 1, i1 false)
205 %arrayidx = getelementptr inbounds float* %A, i64 1 ; <float*> [#uses=1]
206 %tmp2 = load float* %arrayidx ; <float> [#uses=1]
208 ; CHECK-LABEL: @memcpy_to_float_local(
210 ; CHECK: ret float 1.400000e+01
213 ; memcpy from address space 1
214 define float @memcpy_to_float_local_as1(float* %A) nounwind ssp {
216 %conv = bitcast float* %A to i8* ; <i8*> [#uses=1]
217 tail call void @llvm.memcpy.p0i8.p1i8.i64(i8* %conv, i8 addrspace(1)* bitcast ({i32, float, i32 } addrspace(1)* @GCst_as1 to i8 addrspace(1)*), i64 12, i32 1, i1 false)
218 %arrayidx = getelementptr inbounds float* %A, i64 1 ; <float*> [#uses=1]
219 %tmp2 = load float* %arrayidx ; <float> [#uses=1]
221 ; CHECK-LABEL: @memcpy_to_float_local_as1(
223 ; CHECK: ret float 1.400000e+01
226 ;; non-local i32/float -> i8 load forwarding.
227 define i8 @coerce_mustalias_nonlocal0(i32* %P, i1 %cond) {
228 %P2 = bitcast i32* %P to float*
229 %P3 = bitcast i32* %P to i8*
230 br i1 %cond, label %T, label %F
232 store i32 42, i32* %P
236 store float 1.0, float* %P2
243 ; CHECK-LABEL: @coerce_mustalias_nonlocal0(
245 ; CHECK: %A = phi i8 [
251 ;; non-local i32/float -> i8 load forwarding. This also tests that the "P3"
252 ;; bitcast equivalence can be properly phi translated.
253 define i8 @coerce_mustalias_nonlocal1(i32* %P, i1 %cond) {
254 %P2 = bitcast i32* %P to float*
255 br i1 %cond, label %T, label %F
257 store i32 42, i32* %P
261 store float 1.0, float* %P2
265 %P3 = bitcast i32* %P to i8*
269 ; CHECK-LABEL: @coerce_mustalias_nonlocal1(
271 ; CHECK: %A = phi i8 [
277 ;; non-local i32 -> i8 partial redundancy load forwarding.
278 define i8 @coerce_mustalias_pre0(i32* %P, i1 %cond) {
279 %P3 = bitcast i32* %P to i8*
280 br i1 %cond, label %T, label %F
282 store i32 42, i32* %P
292 ; CHECK-LABEL: @coerce_mustalias_pre0(
294 ; CHECK: load i8* %P3
296 ; CHECK: %A = phi i8 [
301 ;;===----------------------------------------------------------------------===;;
302 ;; Store -> Load and Load -> Load forwarding where src and dst are different
303 ;; types, and the reload is an offset from the store pointer.
304 ;;===----------------------------------------------------------------------===;;
306 ;; i32 -> i8 forwarding.
308 define i8 @coerce_offset0(i32 %V, i32* %P) {
309 store i32 %V, i32* %P
311 %P2 = bitcast i32* %P to i8*
312 %P3 = getelementptr i8* %P2, i32 2
316 ; CHECK-LABEL: @coerce_offset0(
321 define i8 @coerce_offset0_addrspacecast(i32 %V, i32* %P) {
322 store i32 %V, i32* %P
324 %P2 = addrspacecast i32* %P to i8 addrspace(1)*
325 %P3 = getelementptr i8 addrspace(1)* %P2, i32 2
327 %A = load i8 addrspace(1)* %P3
329 ; CHECK-LABEL: @coerce_offset0_addrspacecast(
334 ;; non-local i32/float -> i8 load forwarding.
335 define i8 @coerce_offset_nonlocal0(i32* %P, i1 %cond) {
336 %P2 = bitcast i32* %P to float*
337 %P3 = bitcast i32* %P to i8*
338 %P4 = getelementptr i8* %P3, i32 2
339 br i1 %cond, label %T, label %F
341 store i32 57005, i32* %P
345 store float 1.0, float* %P2
352 ; CHECK-LABEL: @coerce_offset_nonlocal0(
354 ; CHECK: %A = phi i8 [
360 ;; non-local i32 -> i8 partial redundancy load forwarding.
361 define i8 @coerce_offset_pre0(i32* %P, i1 %cond) {
362 %P3 = bitcast i32* %P to i8*
363 %P4 = getelementptr i8* %P3, i32 2
364 br i1 %cond, label %T, label %F
366 store i32 42, i32* %P
376 ; CHECK-LABEL: @coerce_offset_pre0(
378 ; CHECK: load i8* %P4
380 ; CHECK: %A = phi i8 [
385 define i32 @chained_load(i32** %p, i32 %x, i32 %y) {
390 store i32* %z, i32** %A
391 %cmp = icmp eq i32 %x, %y
392 br i1 %cmp, label %block2, label %block3
407 ; CHECK-LABEL: @chained_load(
408 ; CHECK: %z = load i32** %p
410 ; CHECK: %d = load i32* %z
411 ; CHECK-NEXT: ret i32 %d
415 declare i1 @cond() readonly
416 declare i1 @cond2() readonly
418 define i32 @phi_trans2() {
419 ; CHECK-LABEL: @phi_trans2(
421 %P = alloca i32, i32 400
425 %A = phi i32 [1, %entry], [2, %F]
426 %cond2 = call i1 @cond()
427 br i1 %cond2, label %T1, label %TY
430 %P2 = getelementptr i32* %P, i32 %A
432 %cond = call i1 @cond2()
433 br i1 %cond, label %TX, label %F
436 %P3 = getelementptr i32* %P, i32 2
437 store i32 17, i32* %P3
439 store i32 42, i32* %P2 ; Provides "P[A]".
443 ; This load should not be compiled to 'ret i32 42'. An overly clever
444 ; implementation of GVN would see that we're returning 17 if the loop
445 ; executes once or 42 if it executes more than that, but we'd have to do
446 ; loop restructuring to expose this, and GVN shouldn't do this sort of CFG
456 define i32 @phi_trans3(i32* %p, i32 %x, i32 %y, i32 %z) {
457 ; CHECK-LABEL: @phi_trans3(
459 %cmpxy = icmp eq i32 %x, %y
460 br i1 %cmpxy, label %block2, label %block3
463 store i32 87, i32* %p
467 %p2 = getelementptr i32* %p, i32 43
468 store i32 97, i32* %p2
472 %A = phi i32 [-1, %block2], [42, %block3]
473 br i1 %cmpxy, label %block5, label %exit
476 ; CHECK-NEXT: %D = phi i32 [ 87, %block2 ], [ 97, %block3 ]
481 br i1 %cmpxy, label %block6, label %exit
484 %C = getelementptr i32* %p, i32 %B
485 br i1 %cmpxy, label %block7, label %exit
492 ; CHECK-NEXT: ret i32 %D
498 define i8 @phi_trans4(i8* %p) {
499 ; CHECK-LABEL: @phi_trans4(
501 %X3 = getelementptr i8* %p, i32 192
502 store i8 192, i8* %X3
504 %X = getelementptr i8* %p, i32 4
509 %i = phi i32 [4, %entry], [192, %loop]
510 %X2 = getelementptr i8* %p, i32 %i
514 ; CHECK-NEXT: %Y2 = phi i8 [ %Y, %entry ], [ 0, %loop ]
517 %cond = call i1 @cond2()
519 %Z = bitcast i8 *%X3 to i32*
521 br i1 %cond, label %loop, label %out
528 define i8 @phi_trans5(i8* %p) {
529 ; CHECK-LABEL: @phi_trans5(
532 %X4 = getelementptr i8* %p, i32 2
535 %X = getelementptr i8* %p, i32 4
540 %i = phi i32 [4, %entry], [3, %cont]
541 %X2 = getelementptr i8* %p, i32 %i
542 %Y2 = load i8* %X2 ; Ensure this load is not being incorrectly replaced.
543 %cond = call i1 @cond2()
544 br i1 %cond, label %cont, label %out
547 %Z = getelementptr i8* %X2, i32 -1
548 %Z2 = bitcast i8 *%Z to i32*
549 store i32 50462976, i32* %Z2 ;; (1 << 8) | (2 << 16) | (3 << 24)
553 ; CHECK-NEXT: getelementptr i8* %p, i32 3
554 ; CHECK-NEXT: load i8*
564 define i32 @memset_to_load() nounwind readnone {
566 %x = alloca [256 x i32], align 4 ; <[256 x i32]*> [#uses=2]
567 %tmp = bitcast [256 x i32]* %x to i8* ; <i8*> [#uses=1]
568 call void @llvm.memset.p0i8.i64(i8* %tmp, i8 0, i64 1024, i32 4, i1 false)
569 %arraydecay = getelementptr inbounds [256 x i32]* %x, i32 0, i32 0 ; <i32*>
570 %tmp1 = load i32* %arraydecay ; <i32> [#uses=1]
572 ; CHECK-LABEL: @memset_to_load(
577 ;;===----------------------------------------------------------------------===;;
578 ;; Load -> Load forwarding in partial alias case.
579 ;;===----------------------------------------------------------------------===;;
581 define i32 @load_load_partial_alias(i8* %P) nounwind ssp {
583 %0 = bitcast i8* %P to i32*
585 %add.ptr = getelementptr inbounds i8* %P, i64 1
586 %tmp5 = load i8* %add.ptr
587 %conv = zext i8 %tmp5 to i32
588 %add = add nsw i32 %tmp2, %conv
591 ; TEMPORARILYDISABLED-LABEL: @load_load_partial_alias(
592 ; TEMPORARILYDISABLED: load i32*
593 ; TEMPORARILYDISABLED-NOT: load
594 ; TEMPORARILYDISABLED: lshr i32 {{.*}}, 8
595 ; TEMPORARILYDISABLED-NOT: load
596 ; TEMPORARILYDISABLED: trunc i32 {{.*}} to i8
597 ; TEMPORARILYDISABLED-NOT: load
598 ; TEMPORARILYDISABLED: ret i32
602 ; Cross block partial alias case.
603 define i32 @load_load_partial_alias_cross_block(i8* %P) nounwind ssp {
605 %xx = bitcast i8* %P to i32*
606 %x1 = load i32* %xx, align 4
607 %cmp = icmp eq i32 %x1, 127
608 br i1 %cmp, label %land.lhs.true, label %if.end
610 land.lhs.true: ; preds = %entry
611 %arrayidx4 = getelementptr inbounds i8* %P, i64 1
612 %tmp5 = load i8* %arrayidx4, align 1
613 %conv6 = zext i8 %tmp5 to i32
618 ; TEMPORARILY_DISABLED-LABEL: @load_load_partial_alias_cross_block(
619 ; TEMPORARILY_DISABLED: land.lhs.true:
620 ; TEMPORARILY_DISABLED-NOT: load i8
621 ; TEMPORARILY_DISABLED: ret i32 %conv6
625 ;;===----------------------------------------------------------------------===;;
627 ;;===----------------------------------------------------------------------===;;
629 %widening1 = type { i32, i8, i8, i8, i8 }
631 @f = global %widening1 zeroinitializer, align 4
633 define i32 @test_widening1(i8* %P) nounwind ssp noredzone {
635 %tmp = load i8* getelementptr inbounds (%widening1* @f, i64 0, i32 1), align 4
636 %conv = zext i8 %tmp to i32
637 %tmp1 = load i8* getelementptr inbounds (%widening1* @f, i64 0, i32 2), align 1
638 %conv2 = zext i8 %tmp1 to i32
639 %add = add nsw i32 %conv, %conv2
641 ; CHECK-LABEL: @test_widening1(
648 define i32 @test_widening2() nounwind ssp noredzone {
650 %tmp = load i8* getelementptr inbounds (%widening1* @f, i64 0, i32 1), align 4
651 %conv = zext i8 %tmp to i32
652 %tmp1 = load i8* getelementptr inbounds (%widening1* @f, i64 0, i32 2), align 1
653 %conv2 = zext i8 %tmp1 to i32
654 %add = add nsw i32 %conv, %conv2
656 %tmp2 = load i8* getelementptr inbounds (%widening1* @f, i64 0, i32 3), align 2
657 %conv3 = zext i8 %tmp2 to i32
658 %add2 = add nsw i32 %add, %conv3
660 %tmp3 = load i8* getelementptr inbounds (%widening1* @f, i64 0, i32 4), align 1
661 %conv4 = zext i8 %tmp3 to i32
662 %add3 = add nsw i32 %add2, %conv3
665 ; CHECK-LABEL: @test_widening2(
672 declare void @llvm.memset.p0i8.i64(i8* nocapture, i8, i64, i32, i1) nounwind
674 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture, i64, i32, i1) nounwind
675 declare void @llvm.memcpy.p0i8.p1i8.i64(i8* nocapture, i8 addrspace(1)* nocapture, i64, i32, i1) nounwind
678 ;;===----------------------------------------------------------------------===;;
679 ;; Load -> Store dependency which isn't interfered with by a call that happens
680 ;; before the pointer was captured.
681 ;;===----------------------------------------------------------------------===;;
683 %class.X = type { [8 x i8] }
685 @_ZTV1X = weak_odr constant [5 x i8*] zeroinitializer
686 @_ZTV1Y = weak_odr constant [5 x i8*] zeroinitializer
689 declare void @use3(i8***, i8**)
692 define void @test_escape1() nounwind {
693 %x = alloca i8**, align 8
694 store i8** getelementptr inbounds ([5 x i8*]* @_ZTV1X, i64 0, i64 2), i8*** %x, align 8
695 call void @use() nounwind
696 %DEAD = load i8*** %x, align 8
697 call void @use3(i8*** %x, i8** %DEAD) nounwind
699 ; CHECK: test_escape1