mirror of
https://github.com/RPCS3/llvm.git
synced 2025-01-09 21:50:50 +00:00
5d8f37f825
This is a follow up to http://reviews.llvm.org/D11995 implementing the suggestion by Hans. If we know some of the bits of the value being switched on, we know that the maximum number of unique cases covers the unknown bits. This allows to eliminate switch defaults for large integers (i32) when most bits in the value are known. Note that I had to make the transform contingent on not having any dead cases. This is conservatively correct with the old code, but required for the new code since we might have a dead case which varies one of the known bits. Counting that towards our number of covering cases would be bad. If we do have dead cases, we'll eliminate them first, then revisit the possibly dead default. Differential Revision: http://reviews.llvm.org/D12497 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@247309 91177308-0d34-0410-b5e6-96231b3b80d8
180 lines
4.1 KiB
LLVM
180 lines
4.1 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)
|
|
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)
|
|
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)
|
|
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)
|
|
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)
|