From a86343512845c9c1fdbac865fea88aa5fce7142a Mon Sep 17 00:00:00 2001
From: Eric Christopher <echristo@gmail.com>
Date: Wed, 17 Apr 2019 02:12:23 +0000
Subject: Temporarily Revert "Add basic loop fusion pass." As it's causing some
 bot failures (and per request from kbarton).

This reverts commit r358543/ab70da07286e618016e78247e4a24fcb84077fda.

llvm-svn: 358546
---
 .../LowerSwitch/2003-05-01-PHIProblem.ll           |  15 -
 .../LowerSwitch/2003-08-23-EmptySwitch.ll          |   9 -
 .../LowerSwitch/2004-03-13-SwitchIsDefaultCrash.ll |  19 -
 .../LowerSwitch/2014-06-10-SwitchContiguousOpt.ll  |  27 -
 .../2014-06-11-SwitchDefaultUnreachableOpt.ll      |  44 -
 .../LowerSwitch/2014-06-23-PHIlowering.ll          |  40 -
 .../LowerSwitch/delete-default-block-crash.ll      |  27 -
 .../LowerSwitch/do-not-handle-impossible-values.ll | 895 ---------------------
 llvm/test/Transforms/LowerSwitch/feature.ll        | 104 ---
 .../fold-popular-case-to-unreachable-default.ll    | 110 ---
 .../Transforms/LowerSwitch/phi-in-dead-block.ll    |  40 -
 11 files changed, 1330 deletions(-)
 delete mode 100644 llvm/test/Transforms/LowerSwitch/2003-05-01-PHIProblem.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/2003-08-23-EmptySwitch.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/2004-03-13-SwitchIsDefaultCrash.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/2014-06-10-SwitchContiguousOpt.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/2014-06-11-SwitchDefaultUnreachableOpt.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/2014-06-23-PHIlowering.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/delete-default-block-crash.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/do-not-handle-impossible-values.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/feature.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/fold-popular-case-to-unreachable-default.ll
 delete mode 100644 llvm/test/Transforms/LowerSwitch/phi-in-dead-block.ll

(limited to 'llvm/test/Transforms/LowerSwitch')

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
-}
-- 
cgit v1.2.3