cb9f78e1c3
There was an efficiency problem with how we processed @llvm.assume in ValueTracking (and other places). The AssumptionCache tracked all of the assumptions in a given function. In order to find assumptions relevant to computing known bits, etc. we searched every assumption in the function. For ValueTracking, that means that we did O(#assumes * #values) work in InstCombine and other passes (with a constant factor that can be quite large because we'd repeat this search at every level of recursion of the analysis). Several of us discussed this situation at the last developers' meeting, and this implements the discussed solution: Make the values that an assume might affect operands of the assume itself. To avoid exposing this detail to frontends and passes that need not worry about it, I've used the new operand-bundle feature to add these extra call "operands" in a way that does not affect the intrinsic's signature. I think this solution is relatively clean. InstCombine adds these extra operands based on what ValueTracking, LVI, etc. will need and then those passes need only search the users of the values under consideration. This should fix the computational-complexity problem. At this point, no passes depend on the AssumptionCache, and so I'll remove that as a follow-up change. Differential Revision: https://reviews.llvm.org/D27259 llvm-svn: 289755
180 lines
4.2 KiB
LLVM
180 lines
4.2 KiB
LLVM
; RUN: opt %s -S -simplifycfg | FileCheck %s
|
|
declare void @foo(i32)
|
|
|
|
define void @test(i1 %a) {
|
|
; CHECK-LABEL: @test
|
|
; CHECK: br i1 [[IGNORE:%.*]], label %true, label %false
|
|
switch i1 %a, label %default [i1 1, label %true
|
|
i1 0, label %false]
|
|
true:
|
|
call void @foo(i32 1)
|
|
ret void
|
|
false:
|
|
call void @foo(i32 3)
|
|
ret void
|
|
default:
|
|
call void @foo(i32 2)
|
|
ret void
|
|
}
|
|
|
|
define void @test2(i2 %a) {
|
|
; CHECK-LABEL: @test2
|
|
switch i2 %a, label %default [i2 0, label %case0
|
|
i2 1, label %case1
|
|
i2 2, label %case2
|
|
i2 3, label %case3]
|
|
case0:
|
|
call void @foo(i32 0)
|
|
ret void
|
|
case1:
|
|
call void @foo(i32 1)
|
|
ret void
|
|
case2:
|
|
call void @foo(i32 2)
|
|
ret void
|
|
case3:
|
|
call void @foo(i32 3)
|
|
ret void
|
|
default:
|
|
; CHECK-LABEL: default1:
|
|
; CHECK-NEXT: unreachable
|
|
call void @foo(i32 4)
|
|
ret void
|
|
}
|
|
|
|
; This one is a negative test - we know the value of the default,
|
|
; but that's about it
|
|
define void @test3(i2 %a) {
|
|
; CHECK-LABEL: @test3
|
|
switch i2 %a, label %default [i2 0, label %case0
|
|
i2 1, label %case1
|
|
i2 2, label %case2]
|
|
|
|
case0:
|
|
call void @foo(i32 0)
|
|
ret void
|
|
case1:
|
|
call void @foo(i32 1)
|
|
ret void
|
|
case2:
|
|
call void @foo(i32 2)
|
|
ret void
|
|
default:
|
|
; CHECK-LABEL: default:
|
|
; CHECK-NEXT: call void @foo
|
|
call void @foo(i32 0)
|
|
ret void
|
|
}
|
|
|
|
; Negative test - check for possible overflow when computing
|
|
; number of possible cases.
|
|
define void @test4(i128 %a) {
|
|
; CHECK-LABEL: @test4
|
|
switch i128 %a, label %default [i128 0, label %case0
|
|
i128 1, label %case1]
|
|
|
|
case0:
|
|
call void @foo(i32 0)
|
|
ret void
|
|
case1:
|
|
call void @foo(i32 1)
|
|
ret void
|
|
default:
|
|
; CHECK-LABEL: default:
|
|
; CHECK-NEXT: call void @foo
|
|
call void @foo(i32 0)
|
|
ret void
|
|
}
|
|
|
|
; All but one bit known zero
|
|
define void @test5(i8 %a) {
|
|
; CHECK-LABEL: @test5
|
|
; CHECK: br i1 [[IGNORE:%.*]], label %true, label %false
|
|
%cmp = icmp ult i8 %a, 2
|
|
call void @llvm.assume(i1 %cmp) [ "affected"(i8 %a) ]
|
|
switch i8 %a, label %default [i8 1, label %true
|
|
i8 0, label %false]
|
|
true:
|
|
call void @foo(i32 1)
|
|
ret void
|
|
false:
|
|
call void @foo(i32 3)
|
|
ret void
|
|
default:
|
|
call void @foo(i32 2)
|
|
ret void
|
|
}
|
|
|
|
;; All but one bit known one
|
|
define void @test6(i8 %a) {
|
|
; CHECK-LABEL: @test6
|
|
; CHECK: @llvm.assume
|
|
; CHECK: br i1 [[IGNORE:%.*]], label %true, label %false
|
|
%and = and i8 %a, 254
|
|
%cmp = icmp eq i8 %and, 254
|
|
call void @llvm.assume(i1 %cmp) [ "affected"(i8 %and, i8 %a) ]
|
|
switch i8 %a, label %default [i8 255, label %true
|
|
i8 254, label %false]
|
|
true:
|
|
call void @foo(i32 1)
|
|
ret void
|
|
false:
|
|
call void @foo(i32 3)
|
|
ret void
|
|
default:
|
|
call void @foo(i32 2)
|
|
ret void
|
|
}
|
|
|
|
; Check that we can eliminate both dead cases and dead defaults
|
|
; within a single run of simplify-cfg
|
|
define void @test7(i8 %a) {
|
|
; CHECK-LABEL: @test7
|
|
; CHECK: @llvm.assume
|
|
; CHECK: br i1 [[IGNORE:%.*]], label %true, label %false
|
|
%and = and i8 %a, 254
|
|
%cmp = icmp eq i8 %and, 254
|
|
call void @llvm.assume(i1 %cmp) [ "affected"(i8 %and, i8 %a) ]
|
|
switch i8 %a, label %default [i8 255, label %true
|
|
i8 254, label %false
|
|
i8 0, label %also_dead]
|
|
true:
|
|
call void @foo(i32 1)
|
|
ret void
|
|
false:
|
|
call void @foo(i32 3)
|
|
ret void
|
|
also_dead:
|
|
call void @foo(i32 5)
|
|
ret void
|
|
default:
|
|
call void @foo(i32 2)
|
|
ret void
|
|
}
|
|
|
|
;; All but one bit known undef
|
|
;; Note: This is currently testing an optimization which doesn't trigger. The
|
|
;; case this is protecting against is that a bit could be assumed both zero
|
|
;; *or* one given we know it's undef. ValueTracking doesn't do this today,
|
|
;; but it doesn't hurt to confirm.
|
|
define void @test8(i8 %a) {
|
|
; CHECK-LABEL: @test8(
|
|
; CHECK: switch i8
|
|
%and = and i8 %a, 254
|
|
%cmp = icmp eq i8 %and, undef
|
|
call void @llvm.assume(i1 %cmp) [ "affected"(i8 %and, i8 %a) ]
|
|
switch i8 %a, label %default [i8 255, label %true
|
|
i8 254, label %false]
|
|
true:
|
|
call void @foo(i32 1)
|
|
ret void
|
|
false:
|
|
call void @foo(i32 3)
|
|
ret void
|
|
default:
|
|
call void @foo(i32 2)
|
|
ret void
|
|
}
|
|
|
|
declare void @llvm.assume(i1)
|