diff --git a/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..1f20349fdec
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff
@@ -0,0 +1,42 @@
+- // MIR for `match_i128_u128` before MatchBranchSimplification
++ // MIR for `match_i128_u128` after MatchBranchSimplification
+  
+  fn match_i128_u128(_1: EnumAi128) -> u128 {
+      debug i => _1;
+      let mut _0: u128;
+      let mut _2: i128;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [1: bb3, 2: bb4, 3: bb5, 340282366920938463463374607431768211455: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = const core::num::<impl u128>::MAX;
+          goto -> bb6;
+      }
+  
+      bb3: {
+          _0 = const 1_u128;
+          goto -> bb6;
+      }
+  
+      bb4: {
+          _0 = const 2_u128;
+          goto -> bb6;
+      }
+  
+      bb5: {
+          _0 = const 3_u128;
+          goto -> bb6;
+      }
+  
+      bb6: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_i16_i8.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_i16_i8.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..4b435310916
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_i16_i8.MatchBranchSimplification.diff
@@ -0,0 +1,37 @@
+- // MIR for `match_i16_i8` before MatchBranchSimplification
++ // MIR for `match_i16_i8` after MatchBranchSimplification
+  
+  fn match_i16_i8(_1: EnumAi16) -> i8 {
+      debug i => _1;
+      let mut _0: i8;
+      let mut _2: i16;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [65535: bb3, 2: bb4, 65533: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = const -3_i8;
+          goto -> bb5;
+      }
+  
+      bb3: {
+          _0 = const -1_i8;
+          goto -> bb5;
+      }
+  
+      bb4: {
+          _0 = const 2_i8;
+          goto -> bb5;
+      }
+  
+      bb5: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_i8_i16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_i8_i16.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..8a390736add
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_i8_i16.MatchBranchSimplification.diff
@@ -0,0 +1,37 @@
+- // MIR for `match_i8_i16` before MatchBranchSimplification
++ // MIR for `match_i8_i16` after MatchBranchSimplification
+  
+  fn match_i8_i16(_1: EnumAi8) -> i16 {
+      debug i => _1;
+      let mut _0: i16;
+      let mut _2: i8;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [255: bb3, 2: bb4, 253: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = const -3_i16;
+          goto -> bb5;
+      }
+  
+      bb3: {
+          _0 = const -1_i16;
+          goto -> bb5;
+      }
+  
+      bb4: {
+          _0 = const 2_i16;
+          goto -> bb5;
+      }
+  
+      bb5: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_i8_i16_failed.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_i8_i16_failed.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..b0217792294
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_i8_i16_failed.MatchBranchSimplification.diff
@@ -0,0 +1,37 @@
+- // MIR for `match_i8_i16_failed` before MatchBranchSimplification
++ // MIR for `match_i8_i16_failed` after MatchBranchSimplification
+  
+  fn match_i8_i16_failed(_1: EnumAi8) -> i16 {
+      debug i => _1;
+      let mut _0: i16;
+      let mut _2: i8;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [255: bb3, 2: bb4, 253: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = const 3_i16;
+          goto -> bb5;
+      }
+  
+      bb3: {
+          _0 = const -1_i16;
+          goto -> bb5;
+      }
+  
+      bb4: {
+          _0 = const 2_i16;
+          goto -> bb5;
+      }
+  
+      bb5: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i16.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..72ad60956ab
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i16.MatchBranchSimplification.diff
@@ -0,0 +1,32 @@
+- // MIR for `match_u8_i16` before MatchBranchSimplification
++ // MIR for `match_u8_i16` after MatchBranchSimplification
+  
+  fn match_u8_i16(_1: EnumAu8) -> i16 {
+      debug i => _1;
+      let mut _0: i16;
+      let mut _2: u8;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [1: bb3, 2: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = const 2_i16;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = const 1_i16;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i16_2.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i16_2.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..3333cd765a8
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i16_2.MatchBranchSimplification.diff
@@ -0,0 +1,26 @@
+- // MIR for `match_u8_i16_2` before MatchBranchSimplification
++ // MIR for `match_u8_i16_2` after MatchBranchSimplification
+  
+  fn match_u8_i16_2(_1: EnumAu8) -> i16 {
+      let mut _0: i16;
+      let mut _2: u8;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(_2) -> [1: bb3, 2: bb1, otherwise: bb2];
+      }
+  
+      bb1: {
+          _0 = const 2_i16;
+          goto -> bb3;
+      }
+  
+      bb2: {
+          unreachable;
+      }
+  
+      bb3: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i16_failed.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i16_failed.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..6da19e46dab
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i16_failed.MatchBranchSimplification.diff
@@ -0,0 +1,32 @@
+- // MIR for `match_u8_i16_failed` before MatchBranchSimplification
++ // MIR for `match_u8_i16_failed` after MatchBranchSimplification
+  
+  fn match_u8_i16_failed(_1: EnumAu8) -> i16 {
+      debug i => _1;
+      let mut _0: i16;
+      let mut _2: u8;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [1: bb3, 2: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = const 3_i16;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = const 1_i16;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_i16_fallback.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_i16_fallback.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..8fa497fe890
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_i16_fallback.MatchBranchSimplification.diff
@@ -0,0 +1,31 @@
+- // MIR for `match_u8_i16_fallback` before MatchBranchSimplification
++ // MIR for `match_u8_i16_fallback` after MatchBranchSimplification
+  
+  fn match_u8_i16_fallback(_1: u8) -> i16 {
+      debug i => _1;
+      let mut _0: i16;
+  
+      bb0: {
+          switchInt(_1) -> [1: bb2, 2: bb3, otherwise: bb1];
+      }
+  
+      bb1: {
+          _0 = const 3_i16;
+          goto -> bb4;
+      }
+  
+      bb2: {
+          _0 = const 1_i16;
+          goto -> bb4;
+      }
+  
+      bb3: {
+          _0 = const 2_i16;
+          goto -> bb4;
+      }
+  
+      bb4: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_u16.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_u16.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..043fdb197a3
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_u16.MatchBranchSimplification.diff
@@ -0,0 +1,37 @@
+- // MIR for `match_u8_u16` before MatchBranchSimplification
++ // MIR for `match_u8_u16` after MatchBranchSimplification
+  
+  fn match_u8_u16(_1: EnumBu8) -> u16 {
+      debug i => _1;
+      let mut _0: u16;
+      let mut _2: u8;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [1: bb3, 2: bb4, 5: bb2, otherwise: bb1];
+      }
+  
+      bb1: {
+          unreachable;
+      }
+  
+      bb2: {
+          _0 = const 5_u16;
+          goto -> bb5;
+      }
+  
+      bb3: {
+          _0 = const 1_u16;
+          goto -> bb5;
+      }
+  
+      bb4: {
+          _0 = const 2_u16;
+          goto -> bb5;
+      }
+  
+      bb5: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.match_u8_u16_2.MatchBranchSimplification.diff b/tests/mir-opt/matches_reduce_branches.match_u8_u16_2.MatchBranchSimplification.diff
new file mode 100644
index 00000000000..b47de6a52b7
--- /dev/null
+++ b/tests/mir-opt/matches_reduce_branches.match_u8_u16_2.MatchBranchSimplification.diff
@@ -0,0 +1,37 @@
+- // MIR for `match_u8_u16_2` before MatchBranchSimplification
++ // MIR for `match_u8_u16_2` after MatchBranchSimplification
+  
+  fn match_u8_u16_2(_1: EnumBu8) -> i16 {
+      let mut _0: i16;
+      let mut _2: u8;
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(_2) -> [1: bb1, 2: bb2, 5: bb3, otherwise: bb4];
+      }
+  
+      bb1: {
+          _0 = const 1_i16;
+          goto -> bb5;
+      }
+  
+      bb2: {
+          _0 = const 2_i16;
+          goto -> bb5;
+      }
+  
+      bb3: {
+          _0 = const 5_i16;
+          _0 = const 5_i16;
+          goto -> bb5;
+      }
+  
+      bb4: {
+          unreachable;
+      }
+  
+      bb5: {
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/matches_reduce_branches.rs b/tests/mir-opt/matches_reduce_branches.rs
index 4bf14e5a7bd..2e7b7d4e600 100644
--- a/tests/mir-opt/matches_reduce_branches.rs
+++ b/tests/mir-opt/matches_reduce_branches.rs
@@ -1,18 +1,28 @@
-// skip-filecheck
 //@ unit-test: MatchBranchSimplification
 
+#![feature(repr128)]
+#![feature(core_intrinsics)]
+#![feature(custom_mir)]
+
+use std::intrinsics::mir::*;
 
 // EMIT_MIR matches_reduce_branches.foo.MatchBranchSimplification.diff
-// EMIT_MIR matches_reduce_branches.bar.MatchBranchSimplification.diff
-// EMIT_MIR matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff
-
 fn foo(bar: Option<()>) {
+    // CHECK-LABEL: fn foo(
+    // CHECK: = Eq(
+    // CHECK: switchInt
+    // CHECK-NOT: switchInt
     if matches!(bar, None) {
         ()
     }
 }
 
+// EMIT_MIR matches_reduce_branches.bar.MatchBranchSimplification.diff
 fn bar(i: i32) -> (bool, bool, bool, bool) {
+    // CHECK-LABEL: fn bar(
+    // CHECK: = Ne(
+    // CHECK: = Eq(
+    // CHECK-NOT: switchInt
     let a;
     let b;
     let c;
@@ -38,7 +48,10 @@ fn bar(i: i32) -> (bool, bool, bool, bool) {
     (a, b, c, d)
 }
 
+// EMIT_MIR matches_reduce_branches.match_nested_if.MatchBranchSimplification.diff
 fn match_nested_if() -> bool {
+    // CHECK-LABEL: fn match_nested_if(
+    // CHECK-NOT: switchInt
     let val = match () {
         () if if if if true { true } else { false } { true } else { false } {
             true
@@ -53,9 +66,211 @@ fn match_nested_if() -> bool {
     val
 }
 
+#[repr(u8)]
+enum EnumAu8 {
+    A = 1,
+    B = 2,
+}
+
+// EMIT_MIR matches_reduce_branches.match_u8_i16.MatchBranchSimplification.diff
+fn match_u8_i16(i: EnumAu8) -> i16 {
+    // CHECK-LABEL: fn match_u8_i16(
+    // CHECK: switchInt
+    match i {
+        EnumAu8::A => 1,
+        EnumAu8::B => 2,
+    }
+}
+
+// EMIT_MIR matches_reduce_branches.match_u8_i16_2.MatchBranchSimplification.diff
+// Check for different instruction lengths
+#[custom_mir(dialect = "built")]
+fn match_u8_i16_2(i: EnumAu8) -> i16 {
+    // CHECK-LABEL: fn match_u8_i16_2(
+    // CHECK: switchInt
+    mir!(
+        {
+            let a = Discriminant(i);
+            match a {
+                1 => bb1,
+                2 => bb2,
+                _ => unreachable_bb,
+            }
+        }
+        bb1 = {
+            Goto(ret)
+        }
+        bb2 = {
+            RET = 2;
+            Goto(ret)
+        }
+        unreachable_bb = {
+            Unreachable()
+        }
+        ret = {
+            Return()
+        }
+    )
+}
+
+// EMIT_MIR matches_reduce_branches.match_u8_i16_failed.MatchBranchSimplification.diff
+fn match_u8_i16_failed(i: EnumAu8) -> i16 {
+    // CHECK-LABEL: fn match_u8_i16_failed(
+    // CHECK: switchInt
+    match i {
+        EnumAu8::A => 1,
+        EnumAu8::B => 3,
+    }
+}
+
+// EMIT_MIR matches_reduce_branches.match_u8_i16_fallback.MatchBranchSimplification.diff
+fn match_u8_i16_fallback(i: u8) -> i16 {
+    // CHECK-LABEL: fn match_u8_i16_fallback(
+    // CHECK: switchInt
+    match i {
+        1 => 1,
+        2 => 2,
+        _ => 3,
+    }
+}
+
+#[repr(u8)]
+enum EnumBu8 {
+    A = 1,
+    B = 2,
+    C = 5,
+}
+
+// EMIT_MIR matches_reduce_branches.match_u8_u16.MatchBranchSimplification.diff
+fn match_u8_u16(i: EnumBu8) -> u16 {
+    // CHECK-LABEL: fn match_u8_u16(
+    // CHECK: switchInt
+    match i {
+        EnumBu8::A => 1,
+        EnumBu8::B => 2,
+        EnumBu8::C => 5,
+    }
+}
+
+// EMIT_MIR matches_reduce_branches.match_u8_u16_2.MatchBranchSimplification.diff
+// Check for different instruction lengths
+#[custom_mir(dialect = "built")]
+fn match_u8_u16_2(i: EnumBu8) -> i16 {
+    // CHECK-LABEL: fn match_u8_u16_2(
+    // CHECK: switchInt
+    mir!(
+        {
+            let a = Discriminant(i);
+            match a {
+                1 => bb1,
+                2 => bb2,
+                5 => bb5,
+                _ => unreachable_bb,
+            }
+        }
+        bb1 = {
+            RET = 1;
+            Goto(ret)
+        }
+        bb2 = {
+            RET = 2;
+            Goto(ret)
+        }
+        bb5 = {
+            RET = 5;
+            RET = 5;
+            Goto(ret)
+        }
+        unreachable_bb = {
+            Unreachable()
+        }
+        ret = {
+            Return()
+        }
+    )
+}
+
+#[repr(i8)]
+enum EnumAi8 {
+    A = -1,
+    B = 2,
+    C = -3,
+}
+
+// EMIT_MIR matches_reduce_branches.match_i8_i16.MatchBranchSimplification.diff
+fn match_i8_i16(i: EnumAi8) -> i16 {
+    // CHECK-LABEL: fn match_i8_i16(
+    // CHECK: switchInt
+    match i {
+        EnumAi8::A => -1,
+        EnumAi8::B => 2,
+        EnumAi8::C => -3,
+    }
+}
+
+// EMIT_MIR matches_reduce_branches.match_i8_i16_failed.MatchBranchSimplification.diff
+fn match_i8_i16_failed(i: EnumAi8) -> i16 {
+    // CHECK-LABEL: fn match_i8_i16_failed(
+    // CHECK: switchInt
+    match i {
+        EnumAi8::A => -1,
+        EnumAi8::B => 2,
+        EnumAi8::C => 3,
+    }
+}
+
+#[repr(i16)]
+enum EnumAi16 {
+    A = -1,
+    B = 2,
+    C = -3,
+}
+
+// EMIT_MIR matches_reduce_branches.match_i16_i8.MatchBranchSimplification.diff
+fn match_i16_i8(i: EnumAi16) -> i8 {
+    // CHECK-LABEL: fn match_i16_i8(
+    // CHECK: switchInt
+    match i {
+        EnumAi16::A => -1,
+        EnumAi16::B => 2,
+        EnumAi16::C => -3,
+    }
+}
+
+#[repr(i128)]
+enum EnumAi128 {
+    A = 1,
+    B = 2,
+    C = 3,
+    D = -1,
+}
+
+// EMIT_MIR matches_reduce_branches.match_i128_u128.MatchBranchSimplification.diff
+fn match_i128_u128(i: EnumAi128) -> u128 {
+    // CHECK-LABEL: fn match_i128_u128(
+    // CHECK: switchInt
+    match i {
+        EnumAi128::A => 1,
+        EnumAi128::B => 2,
+        EnumAi128::C => 3,
+        EnumAi128::D => u128::MAX,
+    }
+}
+
 fn main() {
     let _ = foo(None);
     let _ = foo(Some(()));
     let _ = bar(0);
     let _ = match_nested_if();
+    let _ = match_u8_i16(EnumAu8::A);
+    let _ = match_u8_i16_2(EnumAu8::A);
+    let _ = match_u8_i16_failed(EnumAu8::A);
+    let _ = match_u8_i16_fallback(1);
+    let _ = match_u8_u16(EnumBu8::A);
+    let _ = match_u8_u16_2(EnumBu8::A);
+    let _ = match_i8_i16(EnumAi8::A);
+    let _ = match_i8_i16_failed(EnumAi8::A);
+    let _ = match_i8_i16(EnumAi8::A);
+    let _ = match_i16_i8(EnumAi16::A);
+    let _ = match_i128_u128(EnumAi128::A);
 }