611 lines
10 KiB
LLVM
611 lines
10 KiB
LLVM
; RUN: opt -jump-threading -S < %s | FileCheck %s
|
|
|
|
declare i32 @f1()
|
|
declare i32 @f2()
|
|
declare void @f3()
|
|
|
|
define i32 @test1(i1 %cond) {
|
|
; CHECK-LABEL: @test1(
|
|
|
|
br i1 %cond, label %T1, label %F1
|
|
|
|
T1:
|
|
%v1 = call i32 @f1()
|
|
br label %Merge
|
|
|
|
F1:
|
|
%v2 = call i32 @f2()
|
|
br label %Merge
|
|
|
|
Merge:
|
|
%A = phi i1 [true, %T1], [false, %F1]
|
|
%B = phi i32 [%v1, %T1], [%v2, %F1]
|
|
br i1 %A, label %T2, label %F2
|
|
|
|
T2:
|
|
; CHECK: T2:
|
|
; CHECK: ret i32 %v1
|
|
call void @f3()
|
|
ret i32 %B
|
|
|
|
F2:
|
|
; CHECK: F2:
|
|
; CHECK: ret i32 %v2
|
|
ret i32 %B
|
|
}
|
|
|
|
|
|
;; cond is known false on Entry -> F1 edge!
|
|
define i32 @test2(i1 %cond) {
|
|
; CHECK-LABEL: @test2(
|
|
Entry:
|
|
br i1 %cond, label %T1, label %F1
|
|
|
|
T1:
|
|
; CHECK: %v1 = call i32 @f1()
|
|
; CHECK: ret i32 47
|
|
%v1 = call i32 @f1()
|
|
br label %Merge
|
|
|
|
F1:
|
|
br i1 %cond, label %Merge, label %F2
|
|
|
|
Merge:
|
|
%B = phi i32 [47, %T1], [192, %F1]
|
|
ret i32 %B
|
|
|
|
F2:
|
|
call void @f3()
|
|
ret i32 12
|
|
}
|
|
|
|
|
|
; Undef handling.
|
|
define i32 @test3(i1 %cond) {
|
|
; CHECK-LABEL: @test3(
|
|
; CHECK-NEXT: T1:
|
|
; CHECK-NEXT: ret i32 42
|
|
br i1 undef, label %T1, label %F1
|
|
|
|
T1:
|
|
ret i32 42
|
|
|
|
F1:
|
|
ret i32 17
|
|
}
|
|
|
|
define i32 @test4(i1 %cond, i1 %cond2) {
|
|
; CHECK-LABEL: @test4(
|
|
|
|
br i1 %cond, label %T1, label %F1
|
|
|
|
T1:
|
|
; CHECK: %v1 = call i32 @f1()
|
|
; CHECK-NEXT: br label %T
|
|
|
|
%v1 = call i32 @f1()
|
|
br label %Merge
|
|
|
|
F1:
|
|
%v2 = call i32 @f2()
|
|
; CHECK: %v2 = call i32 @f2()
|
|
; CHECK-NEXT: br i1 %cond2,
|
|
br label %Merge
|
|
|
|
Merge:
|
|
%A = phi i1 [undef, %T1], [%cond2, %F1]
|
|
%B = phi i32 [%v1, %T1], [%v2, %F1]
|
|
br i1 %A, label %T2, label %F2
|
|
|
|
T2:
|
|
call void @f3()
|
|
ret i32 %B
|
|
|
|
F2:
|
|
ret i32 %B
|
|
}
|
|
|
|
|
|
;; This tests that the branch in 'merge' can be cloned up into T1.
|
|
define i32 @test5(i1 %cond, i1 %cond2) {
|
|
; CHECK-LABEL: @test5(
|
|
|
|
br i1 %cond, label %T1, label %F1
|
|
|
|
T1:
|
|
; CHECK: T1:
|
|
; CHECK-NEXT: %v1 = call i32 @f1()
|
|
; CHECK-NEXT: %cond3 = icmp eq i32 %v1, 412
|
|
; CHECK-NEXT: br i1 %cond3, label %T2, label %F2
|
|
|
|
%v1 = call i32 @f1()
|
|
%cond3 = icmp eq i32 %v1, 412
|
|
br label %Merge
|
|
|
|
F1:
|
|
%v2 = call i32 @f2()
|
|
br label %Merge
|
|
|
|
Merge:
|
|
%A = phi i1 [%cond3, %T1], [%cond2, %F1]
|
|
%B = phi i32 [%v1, %T1], [%v2, %F1]
|
|
br i1 %A, label %T2, label %F2
|
|
|
|
T2:
|
|
call void @f3()
|
|
ret i32 %B
|
|
|
|
F2:
|
|
ret i32 %B
|
|
}
|
|
|
|
|
|
;; Lexically duplicated conditionals should be threaded.
|
|
|
|
|
|
define i32 @test6(i32 %A) {
|
|
; CHECK-LABEL: @test6(
|
|
%tmp455 = icmp eq i32 %A, 42
|
|
br i1 %tmp455, label %BB1, label %BB2
|
|
|
|
; CHECK: call i32 @f2()
|
|
; CHECK-NEXT: ret i32 3
|
|
|
|
; CHECK: call i32 @f1()
|
|
; CHECK-NOT: br
|
|
; CHECK: call void @f3()
|
|
; CHECK-NOT: br
|
|
; CHECK: ret i32 4
|
|
|
|
BB2:
|
|
call i32 @f1()
|
|
br label %BB1
|
|
|
|
|
|
BB1:
|
|
%tmp459 = icmp eq i32 %A, 42
|
|
br i1 %tmp459, label %BB3, label %BB4
|
|
|
|
BB3:
|
|
call i32 @f2()
|
|
ret i32 3
|
|
|
|
BB4:
|
|
call void @f3()
|
|
ret i32 4
|
|
}
|
|
|
|
|
|
;; This tests that the branch in 'merge' can be cloned up into T1.
|
|
;; rdar://7367025
|
|
define i32 @test7(i1 %cond, i1 %cond2) {
|
|
Entry:
|
|
; CHECK-LABEL: @test7(
|
|
%v1 = call i32 @f1()
|
|
br i1 %cond, label %Merge, label %F1
|
|
|
|
F1:
|
|
%v2 = call i32 @f2()
|
|
br label %Merge
|
|
|
|
Merge:
|
|
%B = phi i32 [%v1, %Entry], [%v2, %F1]
|
|
%M = icmp ne i32 %B, %v1
|
|
%N = icmp eq i32 %B, 47
|
|
%O = and i1 %M, %N
|
|
br i1 %O, label %T2, label %F2
|
|
|
|
; CHECK: Merge:
|
|
; CHECK-NOT: phi
|
|
; CHECK-NEXT: %v2 = call i32 @f2()
|
|
|
|
T2:
|
|
call void @f3()
|
|
ret i32 %B
|
|
|
|
F2:
|
|
ret i32 %B
|
|
; CHECK: F2:
|
|
; CHECK-NEXT: phi i32
|
|
}
|
|
|
|
|
|
declare i1 @test8a()
|
|
|
|
define i32 @test8b(i1 %cond, i1 %cond2) {
|
|
; CHECK-LABEL: @test8b(
|
|
T0:
|
|
%A = call i1 @test8a()
|
|
br i1 %A, label %T1, label %F1
|
|
|
|
; CHECK: T0:
|
|
; CHECK-NEXT: call
|
|
; CHECK-NEXT: br i1 %A, label %T1, label %Y
|
|
|
|
T1:
|
|
%B = call i1 @test8a()
|
|
br i1 %B, label %T2, label %F1
|
|
|
|
; CHECK: T1:
|
|
; CHECK-NEXT: call
|
|
; CHECK-NEXT: br i1 %B, label %T2, label %Y
|
|
T2:
|
|
%C = call i1 @test8a()
|
|
br i1 %cond, label %T3, label %F1
|
|
|
|
; CHECK: T2:
|
|
; CHECK-NEXT: call
|
|
; CHECK-NEXT: br i1 %cond, label %T3, label %Y
|
|
T3:
|
|
ret i32 0
|
|
|
|
F1:
|
|
%D = phi i32 [0, %T0], [0, %T1], [1, %T2]
|
|
%E = icmp eq i32 %D, 1
|
|
%F = and i1 %E, %cond
|
|
br i1 %F, label %X, label %Y
|
|
X:
|
|
call i1 @test8a()
|
|
ret i32 1
|
|
Y:
|
|
ret i32 2
|
|
}
|
|
|
|
|
|
;;; Verify that we can handle constraint propagation through "xor x, 1".
|
|
define i32 @test9(i1 %cond, i1 %cond2) {
|
|
Entry:
|
|
; CHECK-LABEL: @test9(
|
|
%v1 = call i32 @f1()
|
|
br i1 %cond, label %Merge, label %F1
|
|
|
|
; CHECK: Entry:
|
|
; CHECK-NEXT: %v1 = call i32 @f1()
|
|
; CHECK-NEXT: br i1 %cond, label %F2, label %Merge
|
|
|
|
F1:
|
|
%v2 = call i32 @f2()
|
|
br label %Merge
|
|
|
|
Merge:
|
|
%B = phi i32 [%v1, %Entry], [%v2, %F1]
|
|
%M = icmp eq i32 %B, %v1
|
|
%M1 = xor i1 %M, 1
|
|
%N = icmp eq i32 %B, 47
|
|
%O = and i1 %M1, %N
|
|
br i1 %O, label %T2, label %F2
|
|
|
|
; CHECK: Merge:
|
|
; CHECK-NOT: phi
|
|
; CHECK-NEXT: %v2 = call i32 @f2()
|
|
|
|
T2:
|
|
%Q = zext i1 %M to i32
|
|
ret i32 %Q
|
|
|
|
F2:
|
|
ret i32 %B
|
|
; CHECK: F2:
|
|
; CHECK-NEXT: phi i32
|
|
}
|
|
|
|
|
|
|
|
; CHECK: @test10
|
|
declare i32 @test10f1()
|
|
declare i32 @test10f2()
|
|
declare void @test10f3()
|
|
|
|
;; Non-local condition threading.
|
|
define i32 @test10g(i1 %cond) {
|
|
; CHECK-LABEL: @test10g(
|
|
; CHECK-NEXT: br i1 %cond, label %T2, label %F2
|
|
br i1 %cond, label %T1, label %F1
|
|
|
|
T1:
|
|
%v1 = call i32 @test10f1()
|
|
br label %Merge
|
|
|
|
; CHECK: %v1 = call i32 @test10f1()
|
|
; CHECK-NEXT: call void @f3()
|
|
; CHECK-NEXT: ret i32 %v1
|
|
|
|
F1:
|
|
%v2 = call i32 @test10f2()
|
|
br label %Merge
|
|
|
|
Merge:
|
|
%B = phi i32 [%v1, %T1], [%v2, %F1]
|
|
br i1 %cond, label %T2, label %F2
|
|
|
|
T2:
|
|
call void @f3()
|
|
ret i32 %B
|
|
|
|
F2:
|
|
ret i32 %B
|
|
}
|
|
|
|
|
|
; Impossible conditional constraints should get threaded. BB3 is dead here.
|
|
define i32 @test11(i32 %A) {
|
|
; CHECK-LABEL: @test11(
|
|
; CHECK-NEXT: icmp
|
|
; CHECK-NEXT: br i1 %tmp455, label %BB4, label %BB2
|
|
%tmp455 = icmp eq i32 %A, 42
|
|
br i1 %tmp455, label %BB1, label %BB2
|
|
|
|
BB2:
|
|
; CHECK: call i32 @f1()
|
|
; CHECK-NEXT: ret i32 %C
|
|
%C = call i32 @f1()
|
|
ret i32 %C
|
|
|
|
|
|
BB1:
|
|
%tmp459 = icmp eq i32 %A, 43
|
|
br i1 %tmp459, label %BB3, label %BB4
|
|
|
|
BB3:
|
|
call i32 @f2()
|
|
ret i32 3
|
|
|
|
BB4:
|
|
call void @f3()
|
|
ret i32 4
|
|
}
|
|
|
|
;; Correlated value through boolean expression. GCC PR18046.
|
|
define void @test12(i32 %A) {
|
|
; CHECK-LABEL: @test12(
|
|
entry:
|
|
%cond = icmp eq i32 %A, 0
|
|
br i1 %cond, label %bb, label %bb1
|
|
; Should branch to the return block instead of through BB1.
|
|
; CHECK: entry:
|
|
; CHECK-NEXT: %cond = icmp eq i32 %A, 0
|
|
; CHECK-NEXT: br i1 %cond, label %bb1, label %return
|
|
|
|
bb:
|
|
%B = call i32 @test10f2()
|
|
br label %bb1
|
|
|
|
bb1:
|
|
%C = phi i32 [ %A, %entry ], [ %B, %bb ]
|
|
%cond4 = icmp eq i32 %C, 0
|
|
br i1 %cond4, label %bb2, label %return
|
|
|
|
; CHECK: bb1:
|
|
; CHECK-NEXT: %B = call i32 @test10f2()
|
|
; CHECK-NEXT: %cond4 = icmp eq i32 %B, 0
|
|
; CHECK-NEXT: br i1 %cond4, label %bb2, label %return
|
|
|
|
bb2:
|
|
%D = call i32 @test10f2()
|
|
ret void
|
|
|
|
return:
|
|
ret void
|
|
}
|
|
|
|
|
|
;; Duplicate condition to avoid xor of cond.
|
|
;; rdar://7391699
|
|
define i32 @test13(i1 %cond, i1 %cond2) {
|
|
Entry:
|
|
; CHECK-LABEL: @test13(
|
|
%v1 = call i32 @f1()
|
|
br i1 %cond, label %Merge, label %F1
|
|
|
|
F1:
|
|
br label %Merge
|
|
|
|
Merge:
|
|
%B = phi i1 [true, %Entry], [%cond2, %F1]
|
|
%C = phi i32 [192, %Entry], [%v1, %F1]
|
|
%M = icmp eq i32 %C, 192
|
|
%N = xor i1 %B, %M
|
|
br i1 %N, label %T2, label %F2
|
|
|
|
T2:
|
|
ret i32 123
|
|
|
|
F2:
|
|
ret i32 %v1
|
|
|
|
; CHECK: br i1 %cond, label %F2, label %Merge
|
|
|
|
; CHECK: Merge:
|
|
; CHECK-NEXT: %M = icmp eq i32 %v1, 192
|
|
; CHECK-NEXT: %N = xor i1 %cond2, %M
|
|
; CHECK-NEXT: br i1 %N, label %T2, label %F2
|
|
}
|
|
|
|
; CHECK-LABEL: @test14(
|
|
define i32 @test14(i32 %in) {
|
|
entry:
|
|
%A = icmp eq i32 %in, 0
|
|
; CHECK: br i1 %A, label %right_ret, label %merge
|
|
br i1 %A, label %left, label %right
|
|
|
|
; CHECK-NOT: left:
|
|
left:
|
|
br label %merge
|
|
|
|
; CHECK-NOT: right:
|
|
right:
|
|
%B = call i32 @f1()
|
|
br label %merge
|
|
|
|
merge:
|
|
; CHECK-NOT: %C = phi i32 [%in, %left], [%B, %right]
|
|
%C = phi i32 [%in, %left], [%B, %right]
|
|
%D = add i32 %C, 1
|
|
%E = icmp eq i32 %D, 2
|
|
br i1 %E, label %left_ret, label %right_ret
|
|
|
|
; CHECK: left_ret:
|
|
left_ret:
|
|
ret i32 0
|
|
|
|
right_ret:
|
|
ret i32 1
|
|
}
|
|
|
|
; PR5652
|
|
; CHECK-LABEL: @test15(
|
|
define i32 @test15(i32 %len) {
|
|
entry:
|
|
; CHECK: icmp ult i32 %len, 13
|
|
%tmp = icmp ult i32 %len, 13
|
|
br i1 %tmp, label %check, label %exit0
|
|
|
|
exit0:
|
|
ret i32 0
|
|
|
|
check:
|
|
%tmp9 = icmp ult i32 %len, 21
|
|
br i1 %tmp9, label %exit1, label %exit2
|
|
|
|
exit2:
|
|
; CHECK-NOT: ret i32 2
|
|
ret i32 2
|
|
|
|
exit1:
|
|
ret i32 1
|
|
; CHECK: }
|
|
}
|
|
|
|
;;; Verify that we can handle constraint propagation through cast.
|
|
define i32 @test16(i1 %cond) {
|
|
Entry:
|
|
; CHECK-LABEL: @test16(
|
|
br i1 %cond, label %Merge, label %F1
|
|
|
|
; CHECK: Entry:
|
|
; CHECK-NEXT: br i1 %cond, label %F2, label %Merge
|
|
|
|
F1:
|
|
%v1 = call i32 @f1()
|
|
br label %Merge
|
|
|
|
Merge:
|
|
%B = phi i32 [0, %Entry], [%v1, %F1]
|
|
%M = icmp eq i32 %B, 0
|
|
%M1 = zext i1 %M to i32
|
|
%N = icmp eq i32 %M1, 0
|
|
br i1 %N, label %T2, label %F2
|
|
|
|
; CHECK: Merge:
|
|
; CHECK-NOT: phi
|
|
; CHECK-NEXT: %v1 = call i32 @f1()
|
|
|
|
T2:
|
|
%Q = call i32 @f2()
|
|
ret i32 %Q
|
|
|
|
F2:
|
|
ret i32 %B
|
|
; CHECK: F2:
|
|
; CHECK-NEXT: phi i32
|
|
}
|
|
|
|
; In this test we check that block duplication is inhibited by the presence
|
|
; of a function with the 'noduplicate' attribute.
|
|
|
|
declare void @g()
|
|
declare void @j()
|
|
declare void @k()
|
|
|
|
; CHECK-LABEL: define void @h(i32 %p) {
|
|
define void @h(i32 %p) {
|
|
%x = icmp ult i32 %p, 5
|
|
br i1 %x, label %l1, label %l2
|
|
|
|
l1:
|
|
call void @j()
|
|
br label %l3
|
|
|
|
l2:
|
|
call void @k()
|
|
br label %l3
|
|
|
|
l3:
|
|
; CHECK: call void @g() [[$NOD:#[0-9]+]]
|
|
; CHECK-NOT: call void @g() [[$NOD]]
|
|
call void @g() noduplicate
|
|
%y = icmp ult i32 %p, 5
|
|
br i1 %y, label %l4, label %l5
|
|
|
|
l4:
|
|
call void @j()
|
|
ret void
|
|
|
|
l5:
|
|
call void @k()
|
|
ret void
|
|
; CHECK: }
|
|
}
|
|
|
|
define i1 @trunc_switch(i1 %arg) {
|
|
; CHECK-LABEL: @trunc_switch
|
|
top:
|
|
; CHECK: br i1 %arg, label %exitA, label %exitB
|
|
br i1 %arg, label %common, label %B
|
|
|
|
B:
|
|
br label %common
|
|
|
|
common:
|
|
%phi = phi i8 [ 2, %B ], [ 1, %top ]
|
|
%trunc = trunc i8 %phi to i2
|
|
; CHECK-NOT: switch
|
|
switch i2 %trunc, label %unreach [
|
|
i2 1, label %exitA
|
|
i2 -2, label %exitB
|
|
]
|
|
|
|
unreach:
|
|
unreachable
|
|
|
|
exitA:
|
|
ret i1 true
|
|
|
|
exitB:
|
|
ret i1 false
|
|
}
|
|
|
|
; CHECK-LABEL: define void @h_con(i32 %p) {
|
|
define void @h_con(i32 %p) {
|
|
%x = icmp ult i32 %p, 5
|
|
br i1 %x, label %l1, label %l2
|
|
|
|
l1:
|
|
call void @j()
|
|
br label %l3
|
|
|
|
l2:
|
|
call void @k()
|
|
br label %l3
|
|
|
|
l3:
|
|
; CHECK: call void @g() [[$CON:#[0-9]+]]
|
|
; CHECK-NOT: call void @g() [[$CON]]
|
|
call void @g() convergent
|
|
%y = icmp ult i32 %p, 5
|
|
br i1 %y, label %l4, label %l5
|
|
|
|
l4:
|
|
call void @j()
|
|
ret void
|
|
|
|
l5:
|
|
call void @k()
|
|
ret void
|
|
; CHECK: }
|
|
}
|
|
|
|
|
|
; CHECK: attributes [[$NOD]] = { noduplicate }
|
|
; CHECK: attributes [[$CON]] = { convergent }
|