diff options
Diffstat (limited to 'llvm/test/Transforms/LowerSwitch')
11 files changed, 0 insertions, 1330 deletions
diff --git a/llvm/test/Transforms/LowerSwitch/2003-05-01-PHIProblem.ll b/llvm/test/Transforms/LowerSwitch/2003-05-01-PHIProblem.ll deleted file mode 100644 index d143ab05035..00000000000 --- a/llvm/test/Transforms/LowerSwitch/2003-05-01-PHIProblem.ll +++ /dev/null @@ -1,15 +0,0 @@ -; RUN: opt < %s -lowerswitch - -define void @child(i32 %ct.1) { -entry: - switch i32 0, label %return [ - i32 3, label %UnifiedExitNode - i32 0, label %return - ] -return: ; preds = %entry, %entry - %result.0 = phi i32* [ null, %entry ], [ null, %entry ] ; <i32*> [#uses=0] - br label %UnifiedExitNode -UnifiedExitNode: ; preds = %return, %entry - ret void -} - diff --git a/llvm/test/Transforms/LowerSwitch/2003-08-23-EmptySwitch.ll b/llvm/test/Transforms/LowerSwitch/2003-08-23-EmptySwitch.ll deleted file mode 100644 index 61e1dcd345b..00000000000 --- a/llvm/test/Transforms/LowerSwitch/2003-08-23-EmptySwitch.ll +++ /dev/null @@ -1,9 +0,0 @@ -; RUN: opt < %s -lowerswitch - -define void @test() { - switch i32 0, label %Next [ - ] -Next: ; preds = %0 - ret void -} - diff --git a/llvm/test/Transforms/LowerSwitch/2004-03-13-SwitchIsDefaultCrash.ll b/llvm/test/Transforms/LowerSwitch/2004-03-13-SwitchIsDefaultCrash.ll deleted file mode 100644 index 964b07e3066..00000000000 --- a/llvm/test/Transforms/LowerSwitch/2004-03-13-SwitchIsDefaultCrash.ll +++ /dev/null @@ -1,19 +0,0 @@ -; RUN: opt < %s -lowerswitch -disable-output - -define void @solve() { -entry: - %targetBlock = call i16 @solve_code( ) ; <i16> [#uses=1] - br label %codeReplTail -then.1: ; preds = %codeReplTail - ret void -loopexit.0: ; preds = %codeReplTail - ret void -codeReplTail: ; preds = %codeReplTail, %entry - switch i16 %targetBlock, label %codeReplTail [ - i16 0, label %loopexit.0 - i16 1, label %then.1 - ] -} - -declare i16 @solve_code() - diff --git a/llvm/test/Transforms/LowerSwitch/2014-06-10-SwitchContiguousOpt.ll b/llvm/test/Transforms/LowerSwitch/2014-06-10-SwitchContiguousOpt.ll deleted file mode 100644 index 22173b492c4..00000000000 --- a/llvm/test/Transforms/LowerSwitch/2014-06-10-SwitchContiguousOpt.ll +++ /dev/null @@ -1,27 +0,0 @@ -; RUN: opt < %s -lowerswitch -S | FileCheck %s -; CHECK-NOT: icmp eq i32 %0, 1 - -define i32 @foo(i32 %a) #0 { -entry: - %retval = alloca i32, align 4 - %a.addr = alloca i32, align 4 - store i32 %a, i32* %a.addr, align 4 - %0 = load i32, i32* %a.addr, align 4 - switch i32 %0, label %sw.default [ - i32 0, label %sw.bb - i32 1, label %sw.bb1 - i32 2, label %sw.bb2 - ] - -sw.bb: - ret i32 12 - -sw.bb1: - ret i32 4 - -sw.bb2: - ret i32 2 - -sw.default: - ret i32 9 -} diff --git a/llvm/test/Transforms/LowerSwitch/2014-06-11-SwitchDefaultUnreachableOpt.ll b/llvm/test/Transforms/LowerSwitch/2014-06-11-SwitchDefaultUnreachableOpt.ll deleted file mode 100644 index 2652a6cc5e0..00000000000 --- a/llvm/test/Transforms/LowerSwitch/2014-06-11-SwitchDefaultUnreachableOpt.ll +++ /dev/null @@ -1,44 +0,0 @@ -; RUN: opt < %s -lowerswitch -S | FileCheck %s -; -; The switch is lowered with a single icmp. -; CHECK: icmp -; CHECK-NOT: icmp -; -;int foo(int a) { -; -; switch (a) { -; case 0: -; return 10; -; case 1: -; return 3; -; default: -; __builtin_unreachable(); -; } -; -;} - -define i32 @foo(i32 %a) { - %1 = alloca i32, align 4 - %2 = alloca i32, align 4 - store i32 %a, i32* %2, align 4 - %3 = load i32, i32* %2, align 4 - switch i32 %3, label %6 [ - i32 0, label %4 - i32 1, label %5 - ] - -; <label>:4 - store i32 10, i32* %1 - br label %7 - -; <label>:5 - store i32 3, i32* %1 - br label %7 - -; <label>:6 - unreachable - -; <label>:7 - %8 = load i32, i32* %1 - ret i32 %8 -} diff --git a/llvm/test/Transforms/LowerSwitch/2014-06-23-PHIlowering.ll b/llvm/test/Transforms/LowerSwitch/2014-06-23-PHIlowering.ll deleted file mode 100644 index 24f1d3abeb8..00000000000 --- a/llvm/test/Transforms/LowerSwitch/2014-06-23-PHIlowering.ll +++ /dev/null @@ -1,40 +0,0 @@ -; RUN: opt < %s -lowerswitch -S | FileCheck %s - -define i32 @test(i32 %arg) #0 { -; CHECK-LABEL: @test -; CHECK: 2: -; CHECK-NEXT: %res.0 = phi i32 [ 1, %NodeBlock ], [ 2, %1 ] -; CHECK-NEXT: br label %3 -; CHECK: 5: -; CHECK-NEXT: %res.3 = phi i32 [ 0, %NewDefault ], [ %res.2, %4 ] -; CHECK-NEXT: %6 = add nsw i32 %res.3, 1 -; CHECK-NEXT: ret i32 %6 - - switch i32 %arg, label %5 [ - i32 1, label %1 - i32 2, label %2 - i32 3, label %3 - i32 4, label %4 - ] - -1: - br label %2 - -2: - %res.0 = phi i32 [ 1, %0 ], [ 2, %1 ] - br label %3 - -3: - %res.1 = phi i32 [ 0, %0 ], [ %res.0, %2 ] - %phitmp = add nsw i32 %res.1, 2 - br label %4 - -4: - %res.2 = phi i32 [ 1, %0 ], [ %phitmp, %3 ] - br label %5 - -5: - %res.3 = phi i32 [ 0, %0 ], [ %res.2, %4 ] - %6 = add nsw i32 %res.3, 1 - ret i32 %6 -} diff --git a/llvm/test/Transforms/LowerSwitch/delete-default-block-crash.ll b/llvm/test/Transforms/LowerSwitch/delete-default-block-crash.ll deleted file mode 100644 index 23588d56c33..00000000000 --- a/llvm/test/Transforms/LowerSwitch/delete-default-block-crash.ll +++ /dev/null @@ -1,27 +0,0 @@ -; RUN: opt < %s -lowerswitch -disable-output - -; This test verify -lowerswitch does not crash after deleting the default block. - -declare i32 @f(i32) - -define i32 @unreachable(i32 %x) { - -entry: - switch i32 %x, label %unreachable [ - i32 5, label %a - i32 6, label %a - i32 7, label %a - i32 10, label %b - i32 20, label %b - i32 30, label %b - i32 40, label %b - ] -unreachable: - unreachable -a: - %0 = call i32 @f(i32 0) - ret i32 %0 -b: - %1 = call i32 @f(i32 1) - ret i32 %1 -} diff --git a/llvm/test/Transforms/LowerSwitch/do-not-handle-impossible-values.ll b/llvm/test/Transforms/LowerSwitch/do-not-handle-impossible-values.ll deleted file mode 100644 index 71c1ec7ee29..00000000000 --- a/llvm/test/Transforms/LowerSwitch/do-not-handle-impossible-values.ll +++ /dev/null @@ -1,895 +0,0 @@ -; NOTE: Assertions have been autogenerated by utils/update_test_checks.py -; RUN: opt < %s -lowerswitch -S | FileCheck %s - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define i32 @test1(i32 %val) { -; CHECK-LABEL: @test1( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[TRUNC:%.*]] = trunc i32 [[VAL:%.*]] to i2 -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i2 [[TRUNC]], 1 -; CHECK-NEXT: br i1 [[PIVOT]], label [[LEAFBLOCK:%.*]], label [[CASE_1:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i2 [[TRUNC]], -2 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_D:%.*]] -; CHECK: case.D: -; CHECK-NEXT: [[RESD:%.*]] = call i32 @caseD() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %trunc = trunc i32 %val to i2 - switch i2 %trunc, label %case.D [ - i2 1, label %case.1 ; i2 1 - i2 2, label %case.2 ; i2 -2 - ] - ; It's known that %val can not be less than -2 or greater than 1 - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = call i32 @caseD() - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define i32 @test2() { -; CHECK-LABEL: @test2( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal(), !range !0 -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i32 [[VAL]], 2 -; CHECK-NEXT: br i1 [[PIVOT]], label [[CASE_1:%.*]], label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[VAL]], 2 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_D:%.*]] -; CHECK: case.D: -; CHECK-NEXT: [[RESD:%.*]] = call i32 @caseD() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %val = call i32 @getVal(), !range !0 - switch i32 %val, label %case.D [ - i32 1, label %case.1 - i32 2, label %case.2 - ] - ; It's known that %val can not be less than 1 - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = call i32 @caseD() - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Corner case: -; 1) some of the non-default cases are unreachable due to the !range constraint, -; 2) the default case is unreachable as non-default cases cover the range fully. -define i32 @test3() { -; CHECK-LABEL: @test3( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal(), !range !1 -; CHECK-NEXT: br label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[VAL]], 2 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_1:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %val = call i32 @getVal(), !range !1 - switch i32 %val, label %case.D [ - i32 1, label %case.1 - i32 2, label %case.2 - i32 3, label %case.1 - ] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = call i32 @caseD() - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Corner case: -; 1) some of the non-default cases are unreachable due to the !range constraint, -; 2) the default case is still reachable as non-default cases do not cover the -; range fully. -define i32 @test4() { -; CHECK-LABEL: @test4( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal(), !range !2 -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i32 [[VAL]], 2 -; CHECK-NEXT: br i1 [[PIVOT]], label [[CASE_1:%.*]], label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[VAL]], 2 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_D:%.*]] -; CHECK: case.D: -; CHECK-NEXT: [[RESD:%.*]] = call i32 @caseD() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %val = call i32 @getVal(), !range !2 - switch i32 %val, label %case.D [ - i32 1, label %case.1 - i32 2, label %case.2 - ] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = call i32 @caseD() - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Corner case: -; 1) some of the non-default cases are unreachable due to the !range constraint, -; 2) the default case appears to be unreachable as non-default cases cover the -; range fully, but its basic block actually is reachable from the switch via -; one of the non-default cases. -define i32 @test5(i1 %cond) { -; CHECK-LABEL: @test5( -; CHECK-NEXT: entry: -; CHECK-NEXT: br i1 [[COND:%.*]], label [[SWITCH:%.*]], label [[CASE_D:%.*]] -; CHECK: switch: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal(), !range !1 -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i32 [[VAL]], 3 -; CHECK-NEXT: br i1 [[PIVOT]], label [[LEAFBLOCK:%.*]], label [[CASE_1:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[VAL]], 1 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_1]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_D]] -; CHECK: case.D: -; CHECK-NEXT: [[DELTA:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 20, [[NEWDEFAULT]] ] -; CHECK-NEXT: [[RESD_TMP:%.*]] = call i32 @caseD() -; CHECK-NEXT: [[RESD:%.*]] = add i32 [[RESD_TMP]], [[DELTA]] -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - br i1 %cond, label %switch, label %case.D - -switch: - %val = call i32 @getVal(), !range !1 - switch i32 %val, label %case.D [ - i32 1, label %case.1 - i32 2, label %case.D - i32 3, label %case.1 - ] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.D: - %delta = phi i32 [ 0, %entry ], [ 20, %switch ], [ 20, %switch ] - %resD.tmp = call i32 @caseD() - %resD = add i32 %resD.tmp, %delta - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %resD, %case.D ] - ret i32 %res -} - -; Corner case: -; 1) some of the non-default cases are unreachable due to the !range constraint, -; 2) the default case appears to be unreachable as non-default cases cover the -; range fully, but its basic block actually is reachable, though, from a -; different basic block, not the switch itself. -define i32 @test6(i1 %cond) { -; CHECK-LABEL: @test6( -; CHECK-NEXT: entry: -; CHECK-NEXT: br i1 [[COND:%.*]], label [[SWITCH:%.*]], label [[CASE_D:%.*]] -; CHECK: switch: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal(), !range !1 -; CHECK-NEXT: br label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[VAL]], 2 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_1:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: case.D: -; CHECK-NEXT: [[RESD_TMP:%.*]] = call i32 @caseD() -; CHECK-NEXT: [[RESD:%.*]] = add i32 [[RESD_TMP]], 0 -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - br i1 %cond, label %switch, label %case.D - -switch: - %val = call i32 @getVal(), !range !1 - switch i32 %val, label %case.D [ - i32 1, label %case.1 - i32 2, label %case.2 - i32 3, label %case.1 - ] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %delta = phi i32 [ 0, %entry ], [ 20, %switch ] - %resD.tmp = call i32 @caseD() - %resD = add i32 %resD.tmp, %delta - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Corner case: -; 1) switch appears to have a non-empty set of non-default cases, but all of -; them reference the default case basic block. -define i32 @test7(i1 %cond) { -; CHECK-LABEL: @test7( -; CHECK-NEXT: entry: -; CHECK-NEXT: br i1 [[COND:%.*]], label [[SWITCH:%.*]], label [[CASE_D:%.*]] -; CHECK: switch: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal(), !range !1 -; CHECK-NEXT: br label [[CASE_D]] -; CHECK: case.D: -; CHECK-NEXT: [[DELTA:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ 20, [[SWITCH]] ] -; CHECK-NEXT: [[RESD_TMP:%.*]] = call i32 @caseD() -; CHECK-NEXT: [[RESD:%.*]] = add i32 [[RESD_TMP]], [[DELTA]] -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: exit: -; CHECK-NEXT: ret i32 [[RESD]] -; -entry: - br i1 %cond, label %switch, label %case.D - -switch: - %val = call i32 @getVal(), !range !1 - switch i32 %val, label %case.D [ - i32 2, label %case.D - ] - -case.D: - %delta = phi i32 [ 0, %entry ], [ 20, %switch ], [ 20, %switch ] - %resD.tmp = call i32 @caseD() - %resD = add i32 %resD.tmp, %delta - br label %exit - -exit: - ret i32 %resD -} - -; Corner case: -; 1) some of the non-default cases are unreachable due to the !range constraint, -; 2) the default case appears to be unreachable as non-default cases cover the -; range fully, but its basic block actually is reachable from the switch via -; one of the non-default cases, -; 3) such cases lie at the boundary of the range of values covered by -; non-default cases, and if removed, do not change the fact that the rest of -; the cases fully covers the value range. -define i32 @test8(i1 %cond) { -; CHECK-LABEL: @test8( -; CHECK-NEXT: entry: -; CHECK-NEXT: br i1 [[COND:%.*]], label [[SWITCH:%.*]], label [[CASE_D:%.*]] -; CHECK: switch: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal(), !range !3 -; CHECK-NEXT: br label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[VAL]], 2 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_1:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: case.D: -; CHECK-NEXT: [[RESD_TMP:%.*]] = call i32 @caseD() -; CHECK-NEXT: [[RESD:%.*]] = add i32 [[RESD_TMP]], 0 -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - br i1 %cond, label %switch, label %case.D - -switch: - %val = call i32 @getVal(), !range !3 - switch i32 %val, label %case.D [ - i32 1, label %case.1 - i32 2, label %case.2 - i32 3, label %case.D - ] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %delta = phi i32 [ 0, %entry ], [ 20, %switch ], [ 20, %switch ] - %resD.tmp = call i32 @caseD() - %resD = add i32 %resD.tmp, %delta - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Corner case: -; 1) the default case appears to be unreachable as non-default cases cover the -; range fully, but its basic block actually is reachable from the switch via -; more than one non-default case. -define i32 @test9(i1 %cond, i2 %val) { -; CHECK-LABEL: @test9( -; CHECK-NEXT: entry: -; CHECK-NEXT: br i1 [[COND:%.*]], label [[SWITCH:%.*]], label [[CASE_D:%.*]] -; CHECK: switch: -; CHECK-NEXT: br label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp sge i2 [[VAL:%.*]], 0 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_1:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_D]] -; CHECK: case.D: -; CHECK-NEXT: [[DELTA:%.*]] = phi i32 [ 20, [[NEWDEFAULT]] ], [ 0, [[ENTRY:%.*]] ] -; CHECK-NEXT: [[RESD_TMP:%.*]] = call i32 @caseD() -; CHECK-NEXT: [[RESD:%.*]] = add i32 [[RESD_TMP]], [[DELTA]] -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - br i1 %cond, label %switch, label %case.D - -switch: - switch i2 %val, label %case.D [ - i2 0, label %case.1 - i2 1, label %case.1 - i2 2, label %case.D - i2 3, label %case.D - ] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.D: - %delta = phi i32 [20, %switch ], [ 20, %switch ], [ 20, %switch ], [ 0, %entry ] - %resD.tmp = call i32 @caseD() - %resD = add i32 %resD.tmp, %delta - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %resD, %case.D ] - ret i32 %res -} - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define i32 @test10() { -; CHECK-LABEL: @test10( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal() -; CHECK-NEXT: [[COND_LEFT:%.*]] = icmp sge i32 [[VAL]], 1 -; CHECK-NEXT: [[COND_RIGHT:%.*]] = icmp sle i32 [[VAL]], 6 -; CHECK-NEXT: [[COND:%.*]] = and i1 [[COND_LEFT]], [[COND_RIGHT]] -; CHECK-NEXT: br i1 [[COND]], label [[SWITCH:%.*]], label [[CASE_D:%.*]] -; CHECK: switch: -; CHECK-NEXT: br label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[VAL_OFF:%.*]] = add i32 [[VAL]], -3 -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp ule i32 [[VAL_OFF]], 1 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_1:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: case.D: -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ 0, [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %val = call i32 @getVal() - %cond.left = icmp sge i32 %val, 1 - %cond.right = icmp sle i32 %val, 6 - %cond = and i1 %cond.left, %cond.right - br i1 %cond, label %switch, label %case.D - -switch: - switch i32 %val, label %case.D [ - i32 1, label %case.1 - i32 2, label %case.1 - i32 3, label %case.2 - i32 4, label %case.2 - i32 5, label %case.1 - i32 6, label %case.1 - ] - ; It's known that %val <- [1, 6] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = phi i32 [ 20, %switch ], [ 0, %entry ] - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define i32 @test11() { -; CHECK-LABEL: @test11( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[VAL:%.*]] = call i32 @getVal() -; CHECK-NEXT: [[VAL_ZEXT:%.*]] = zext i32 [[VAL]] to i64 -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i64 [[VAL_ZEXT]], 1 -; CHECK-NEXT: br i1 [[PIVOT]], label [[CASE_1:%.*]], label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i64 [[VAL_ZEXT]], 1 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_D:%.*]] -; CHECK: case.D: -; CHECK-NEXT: [[RESD:%.*]] = call i32 @caseD() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %val = call i32 @getVal() - %val.zext = zext i32 %val to i64 - switch i64 %val.zext, label %case.D [ - i64 0, label %case.1 - i64 1, label %case.2 - ] - ; It's known that %val can not be less than 0 - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = call i32 @caseD() - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define void @test12() { -; CHECK-LABEL: @test12( -; CHECK-NEXT: entry: -; CHECK-NEXT: br label [[FOR_BODY:%.*]] -; CHECK: for.body: -; CHECK-NEXT: [[INDVAR:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INC:%.*]], [[LATCH:%.*]] ] -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i32 [[INDVAR]], 1 -; CHECK-NEXT: br i1 [[PIVOT]], label [[CASE_1:%.*]], label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[INDVAR]], 1 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: br label [[LATCH]] -; CHECK: case.2: -; CHECK-NEXT: br label [[LATCH]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[LATCH]] -; CHECK: latch: -; CHECK-NEXT: [[INC]] = add nuw nsw i32 [[INDVAR]], 1 -; CHECK-NEXT: br i1 undef, label [[EXIT:%.*]], label [[FOR_BODY]] -; CHECK: exit: -; CHECK-NEXT: ret void -; -entry: - br label %for.body - -for.body: - %indvar = phi i32 [ 0, %entry ], [ %inc, %latch ] - switch i32 %indvar, label %latch [ - i32 0, label %case.1 - i32 1, label %case.2 - ] - ; It's known that %indvar can not be less than 0 - -case.1: - br label %latch - -case.2: - br label %latch - -latch: - %inc = add nuw nsw i32 %indvar, 1 - br i1 undef, label %exit, label %for.body - -exit: - ret void -} - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define void @test13(i32 %val) { -; CHECK-LABEL: @test13( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[TMP:%.*]] = and i32 [[VAL:%.*]], 7 -; CHECK-NEXT: br label [[BB33:%.*]] -; CHECK: bb33: -; CHECK-NEXT: br label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[TMP_OFF:%.*]] = add i32 [[TMP]], -2 -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp ule i32 [[TMP_OFF]], 1 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[BB34:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: bb34: -; CHECK-NEXT: br label [[BB38:%.*]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[BB35:%.*]] -; CHECK: bb35: -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i32 [[TMP]], 6 -; CHECK-NEXT: br i1 [[PIVOT]], label [[LEAFBLOCK2:%.*]], label [[BB37:%.*]] -; CHECK: LeafBlock2: -; CHECK-NEXT: [[SWITCHLEAF3:%.*]] = icmp sle i32 [[TMP]], 1 -; CHECK-NEXT: br i1 [[SWITCHLEAF3]], label [[BB37]], label [[NEWDEFAULT1:%.*]] -; CHECK: bb37: -; CHECK-NEXT: br label [[BB38]] -; CHECK: NewDefault1: -; CHECK-NEXT: br label [[BB38]] -; CHECK: bb38: -; CHECK-NEXT: br label [[BB33]] -; -entry: - %tmp = and i32 %val, 7 - br label %bb33 - -bb33: - switch i32 %tmp, label %bb35 [ - i32 2, label %bb34 - i32 3, label %bb34 - ] - -bb34: - br label %bb38 - -bb35: - switch i32 %tmp, label %bb38 [ - i32 0, label %bb37 - i32 1, label %bb37 - i32 6, label %bb37 - i32 7, label %bb37 - ] - ; It's known that %tmp <- [0, 1] U [4, 7] - -bb37: - br label %bb38 - -bb38: - br label %bb33 -} - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define i32 @test14() { -; CHECK-LABEL: @test14( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[TMP:%.*]] = call i32 @getVal(), !range !4 -; CHECK-NEXT: [[VAL:%.*]] = call i32 @llvm.ctpop.i32(i32 [[TMP]]) -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i32 [[VAL]], 1 -; CHECK-NEXT: br i1 [[PIVOT]], label [[CASE_1:%.*]], label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[VAL]], 1 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_D:%.*]] -; CHECK: case.D: -; CHECK-NEXT: [[RESD:%.*]] = call i32 @caseD() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %tmp = call i32 @getVal(), !range !4 - %val = call i32 @llvm.ctpop.i32(i32 %tmp) - switch i32 %val, label %case.D [ - i32 0, label %case.1 - i32 1, label %case.2 - ] - ; It's known that %val <- [0, 2] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = call i32 @caseD() - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define i32 @test15() { -; CHECK-LABEL: @test15( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[TMP:%.*]] = call i32 @getVal() -; CHECK-NEXT: [[VAL:%.*]] = urem i32 [[TMP]], 3 -; CHECK-NEXT: br label [[NODEBLOCK:%.*]] -; CHECK: NodeBlock: -; CHECK-NEXT: [[PIVOT:%.*]] = icmp slt i32 [[VAL]], 1 -; CHECK-NEXT: br i1 [[PIVOT]], label [[CASE_1:%.*]], label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp eq i32 [[VAL]], 1 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_D:%.*]] -; CHECK: case.D: -; CHECK-NEXT: [[RESD:%.*]] = call i32 @caseD() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ], [ [[RESD]], [[CASE_D]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %tmp = call i32 @getVal() - %val = urem i32 %tmp, 3 - switch i32 %val, label %case.D [ - i32 0, label %case.1 - i32 1, label %case.2 - ] - ; It's known that %val <- [0, 2] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = call i32 @caseD() - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -; Check that we do not generate redundant comparisons that would have results -; known at compile time due to limited range of the value being switch'ed over. -define i32 @test16(float %f) { -; CHECK-LABEL: @test16( -; CHECK-NEXT: entry: -; CHECK-NEXT: [[I:%.*]] = fptosi float [[F:%.*]] to i64 -; CHECK-NEXT: [[COND_LEFT:%.*]] = icmp slt i64 [[I]], 0 -; CHECK-NEXT: [[CLAMP_LEFT:%.*]] = select i1 [[COND_LEFT]], i64 0, i64 [[I]] -; CHECK-NEXT: [[COND_RIGHT:%.*]] = icmp sgt i64 [[I]], 3 -; CHECK-NEXT: [[CLAMP:%.*]] = select i1 [[COND_RIGHT]], i64 3, i64 [[CLAMP_LEFT]] -; CHECK-NEXT: br label [[LEAFBLOCK:%.*]] -; CHECK: LeafBlock: -; CHECK-NEXT: [[SWITCHLEAF:%.*]] = icmp sge i64 [[CLAMP]], 2 -; CHECK-NEXT: br i1 [[SWITCHLEAF]], label [[CASE_2:%.*]], label [[NEWDEFAULT:%.*]] -; CHECK: NewDefault: -; CHECK-NEXT: br label [[CASE_1:%.*]] -; CHECK: case.1: -; CHECK-NEXT: [[RES1:%.*]] = call i32 @case1() -; CHECK-NEXT: br label [[EXIT:%.*]] -; CHECK: case.2: -; CHECK-NEXT: [[RES2:%.*]] = call i32 @case2() -; CHECK-NEXT: br label [[EXIT]] -; CHECK: exit: -; CHECK-NEXT: [[RES:%.*]] = phi i32 [ [[RES1]], [[CASE_1]] ], [ [[RES2]], [[CASE_2]] ] -; CHECK-NEXT: ret i32 [[RES]] -; -entry: - %i = fptosi float %f to i64 - %cond.left = icmp slt i64 %i, 0 - %clamp.left = select i1 %cond.left, i64 0, i64 %i - %cond.right = icmp sgt i64 %i, 3 - %clamp = select i1 %cond.right, i64 3, i64 %clamp.left - switch i64 %clamp, label %case.D [ - i64 0, label %case.1 - i64 1, label %case.1 - i64 2, label %case.2 - i64 3, label %case.2 - ] - ; It's known that %val <- [0, 3] - -case.1: - %res1 = call i32 @case1() - br label %exit - -case.2: - %res2 = call i32 @case2() - br label %exit - -case.D: - %resD = call i32 @caseD() - br label %exit - -exit: - %res = phi i32 [ %res1, %case.1 ], [ %res2, %case.2 ], [ %resD, %case.D ] - ret i32 %res -} - -declare i32 @case1() -declare i32 @case2() -declare i32 @caseD() -declare i32 @getVal() -declare i32 @llvm.ctpop.i32(i32) - -!0 = !{i32 1, i32 257} -!1 = !{i32 2, i32 3} -!2 = !{i32 2, i32 257} -!3 = !{i32 1, i32 3} -!4 = !{i32 0, i32 4} diff --git a/llvm/test/Transforms/LowerSwitch/feature.ll b/llvm/test/Transforms/LowerSwitch/feature.ll deleted file mode 100644 index 09d25f0b06d..00000000000 --- a/llvm/test/Transforms/LowerSwitch/feature.ll +++ /dev/null @@ -1,104 +0,0 @@ -; RUN: opt < %s -lowerswitch -S | FileCheck %s - -; We have switch on input. -; On output we should got binary comparison tree. Check that all is fine. - -;CHECK: entry: -;CHECK-NEXT: br label %NodeBlock19 - -;CHECK: NodeBlock19: ; preds = %entry -;CHECK-NEXT: %Pivot20 = icmp slt i32 %tmp158, 10 -;CHECK-NEXT: br i1 %Pivot20, label %NodeBlock5, label %NodeBlock17 - -;CHECK: NodeBlock17: ; preds = %NodeBlock19 -;CHECK-NEXT: %Pivot18 = icmp slt i32 %tmp158, 13 -;CHECK-NEXT: br i1 %Pivot18, label %NodeBlock9, label %NodeBlock15 - -;CHECK: NodeBlock15: ; preds = %NodeBlock17 -;CHECK-NEXT: %Pivot16 = icmp slt i32 %tmp158, 14 -;CHECK-NEXT: br i1 %Pivot16, label %bb330, label %NodeBlock13 - -;CHECK: NodeBlock13: ; preds = %NodeBlock15 -;CHECK-NEXT: %Pivot14 = icmp slt i32 %tmp158, 15 -;CHECK-NEXT: br i1 %Pivot14, label %bb332, label %LeafBlock11 - -;CHECK: LeafBlock11: ; preds = %NodeBlock13 -;CHECK-NEXT: %SwitchLeaf12 = icmp eq i32 %tmp158, 15 -;CHECK-NEXT: br i1 %SwitchLeaf12, label %bb334, label %NewDefault - -;CHECK: NodeBlock9: ; preds = %NodeBlock17 -;CHECK-NEXT: %Pivot10 = icmp slt i32 %tmp158, 11 -;CHECK-NEXT: br i1 %Pivot10, label %bb324, label %NodeBlock7 - -;CHECK: NodeBlock7: ; preds = %NodeBlock9 -;CHECK-NEXT: %Pivot8 = icmp slt i32 %tmp158, 12 -;CHECK-NEXT: br i1 %Pivot8, label %bb326, label %bb328 - -;CHECK: NodeBlock5: ; preds = %NodeBlock19 -;CHECK-NEXT: %Pivot6 = icmp slt i32 %tmp158, 7 -;CHECK-NEXT: br i1 %Pivot6, label %NodeBlock, label %NodeBlock3 - -;CHECK: NodeBlock3: ; preds = %NodeBlock5 -;CHECK-NEXT: %Pivot4 = icmp slt i32 %tmp158, 8 -;CHECK-NEXT: br i1 %Pivot4, label %bb, label %NodeBlock1 - -;CHECK: NodeBlock1: ; preds = %NodeBlock3 -;CHECK-NEXT: %Pivot2 = icmp slt i32 %tmp158, 9 -;CHECK-NEXT: br i1 %Pivot2, label %bb338, label %bb322 - -;CHECK: NodeBlock: ; preds = %NodeBlock5 -;CHECK-NEXT: %Pivot = icmp slt i32 %tmp158, 0 -;CHECK-NEXT: br i1 %Pivot, label %LeafBlock, label %bb338 - -;CHECK: LeafBlock: ; preds = %NodeBlock -;CHECK-NEXT: %tmp158.off = add i32 %tmp158, 6 -;CHECK-NEXT: %SwitchLeaf = icmp ule i32 %tmp158.off, 4 -;CHECK-NEXT: br i1 %SwitchLeaf, label %bb338, label %NewDefault - -define i32 @main(i32 %tmp158) { -entry: - - switch i32 %tmp158, label %bb336 [ - i32 -2, label %bb338 - i32 -3, label %bb338 - i32 -4, label %bb338 - i32 -5, label %bb338 - i32 -6, label %bb338 - i32 0, label %bb338 - i32 1, label %bb338 - i32 2, label %bb338 - i32 3, label %bb338 - i32 4, label %bb338 - i32 5, label %bb338 - i32 6, label %bb338 - i32 7, label %bb - i32 8, label %bb338 - i32 9, label %bb322 - i32 10, label %bb324 - i32 11, label %bb326 - i32 12, label %bb328 - i32 13, label %bb330 - i32 14, label %bb332 - i32 15, label %bb334 - ] -bb: - ret i32 2 -bb322: - ret i32 3 -bb324: - ret i32 4 -bb326: - ret i32 5 -bb328: - ret i32 6 -bb330: - ret i32 7 -bb332: - ret i32 8 -bb334: - ret i32 9 -bb336: - ret i32 10 -bb338: - ret i32 11 -} diff --git a/llvm/test/Transforms/LowerSwitch/fold-popular-case-to-unreachable-default.ll b/llvm/test/Transforms/LowerSwitch/fold-popular-case-to-unreachable-default.ll deleted file mode 100644 index 54929c5bfca..00000000000 --- a/llvm/test/Transforms/LowerSwitch/fold-popular-case-to-unreachable-default.ll +++ /dev/null @@ -1,110 +0,0 @@ -; RUN: opt %s -lowerswitch -S | FileCheck %s - -define void @foo(i32 %x, i32* %p) { -; Cases 2 and 4 are removed and become the new default case. -; It is now enough to use two icmps to lower the switch. -; -; CHECK-LABEL: @foo -; CHECK: icmp slt i32 %x, 5 -; CHECK: icmp eq i32 %x, 1 -; CHECK-NOT: icmp -; -entry: - switch i32 %x, label %default [ - i32 1, label %bb0 - i32 2, label %popular - i32 4, label %popular - i32 5, label %bb1 - ] -bb0: - store i32 0, i32* %p - br label %exit -bb1: - store i32 1, i32* %p - br label %exit -popular: - store i32 2, i32* %p - br label %exit -exit: - ret void -default: - unreachable -} - -define void @unreachable_gap(i64 %x, i32* %p) { -; Cases 6 and INT64_MAX become the new default, but we still exploit the fact -; that 3-4 is unreachable, so four icmps is enough. - -; CHECK-LABEL: @unreachable_gap -; CHECK: icmp slt i64 %x, 2 -; CHECK: icmp slt i64 %x, 5 -; CHECK: icmp eq i64 %x, 5 -; CHECK: icmp slt i64 %x, 1 -; CHECK-NOT: icmp - -entry: - switch i64 %x, label %default [ - i64 -9223372036854775808, label %bb0 - i64 1, label %bb1 - i64 2, label %bb2 - i64 5, label %bb3 - i64 6, label %bb4 - i64 9223372036854775807, label %bb4 - ] -bb0: - store i32 0, i32* %p - br label %exit -bb1: - store i32 1, i32* %p - br label %exit -bb2: - store i32 2, i32* %p - br label %exit -bb3: - store i32 3, i32* %p - br label %exit -bb4: - store i32 4, i32* %p - br label %exit -exit: - ret void -default: - unreachable -} - - - -define void @nocases(i32 %x, i32* %p) { -; Don't fall over when there are no cases. -; -; CHECK-LABEL: @nocases -; CHECK-LABEL: entry -; CHECK-NEXT: br label %default -; -entry: - switch i32 %x, label %default [ - ] -default: - unreachable -} - -define void @nocasesleft(i32 %x, i32* %p) { -; Cases 2 and 4 are removed and we are left with no cases. -; -; CHECK-LABEL: @nocasesleft -; CHECK-LABEL: entry -; CHECK-NEXT: br label %popular -; -entry: - switch i32 %x, label %default [ - i32 2, label %popular - i32 4, label %popular - ] -popular: - store i32 2, i32* %p - br label %exit -exit: - ret void -default: - unreachable -} diff --git a/llvm/test/Transforms/LowerSwitch/phi-in-dead-block.ll b/llvm/test/Transforms/LowerSwitch/phi-in-dead-block.ll deleted file mode 100644 index a632584f7eb..00000000000 --- a/llvm/test/Transforms/LowerSwitch/phi-in-dead-block.ll +++ /dev/null @@ -1,40 +0,0 @@ -; RUN: opt -S -lowerswitch %s | FileCheck %s - -; CHECK-LABEL: @phi_in_dead_block( -; CHECK-NOT: switch -define void @phi_in_dead_block() { -bb: - br i1 undef, label %bb2, label %bb3 - -bb1: ; No predecessors! - switch i32 undef, label %bb2 [ - i32 9, label %bb3 - ] - -bb2: ; preds = %bb1, %bb - %tmp = phi i64 [ undef, %bb1 ], [ undef, %bb ] - unreachable - -bb3: ; preds = %bb1, %bb - unreachable -} - -; CHECK-LABEL: @phi_in_dead_block_br_to_self( -; CHECK-NOT: switch -define void @phi_in_dead_block_br_to_self() { -bb: - br i1 undef, label %bb2, label %bb3 - -bb1: ; No predecessors! - switch i32 undef, label %bb2 [ - i32 9, label %bb3 - i32 10, label %bb1 - ] - -bb2: ; preds = %bb1, %bb - %tmp = phi i64 [ undef, %bb1 ], [ undef, %bb ] - unreachable - -bb3: ; preds = %bb1, %bb - unreachable -} |
