tests/mir-opt/gvn.arithmetic_checked.GVN.panic-unwind.diff

- // MIR for `arithmetic_checked` before GVN
+ // MIR for `arithmetic_checked` after GVN
  
  fn arithmetic_checked(_1: u64) -> () {
      debug x => _1;
      let mut _0: ();
      let _2: ();
      let mut _3: u64;
      let mut _4: u64;
      let mut _5: (u64, bool);
      let _6: ();
      let mut _7: u64;
      let mut _8: u64;
      let mut _9: (u64, bool);
      let _10: ();
      let mut _11: u64;
      let mut _12: u64;
      let mut _13: (u64, bool);
      let _14: ();
      let mut _15: u64;
      let mut _16: u64;
      let mut _17: (u64, bool);
  
      bb0: {
          StorageLive(_2);
          StorageLive(_3);
          StorageLive(_4);
          _4 = _1;
-         _5 = CheckedAdd(_4, const 0_u64);
-         assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", move _4, const 0_u64) -> [success: bb1, unwind continue];
+         _5 = CheckedAdd(_1, const 0_u64);
+         assert(!move (_5.1: bool), "attempt to compute `{} + {}`, which would overflow", _1, const 0_u64) -> [success: bb1, unwind continue];
      }
  
      bb1: {
          _3 = move (_5.0: u64);
          StorageDead(_4);
          _2 = opaque::<u64>(move _3) -> [return: bb2, unwind continue];
      }
  
      bb2: {
          StorageDead(_3);
          StorageDead(_2);
          StorageLive(_6);
          StorageLive(_7);
          StorageLive(_8);
          _8 = _1;
-         _9 = CheckedSub(_8, const 0_u64);
-         assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", move _8, const 0_u64) -> [success: bb3, unwind continue];
+         _9 = CheckedSub(_1, const 0_u64);
+         assert(!move (_9.1: bool), "attempt to compute `{} - {}`, which would overflow", _1, const 0_u64) -> [success: bb3, unwind continue];
      }
  
      bb3: {
          _7 = move (_9.0: u64);
          StorageDead(_8);
          _6 = opaque::<u64>(move _7) -> [return: bb4, unwind continue];
      }
  
      bb4: {
          StorageDead(_7);
          StorageDead(_6);
          StorageLive(_10);
          StorageLive(_11);
          StorageLive(_12);
          _12 = _1;
-         _13 = CheckedMul(_12, const 0_u64);
-         assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", move _12, const 0_u64) -> [success: bb5, unwind continue];
+         _13 = CheckedMul(_1, const 0_u64);
+         assert(!move (_13.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 0_u64) -> [success: bb5, unwind continue];
      }
  
      bb5: {
          _11 = move (_13.0: u64);
          StorageDead(_12);
          _10 = opaque::<u64>(move _11) -> [return: bb6, unwind continue];
      }
  
      bb6: {
          StorageDead(_11);
          StorageDead(_10);
          StorageLive(_14);
          StorageLive(_15);
          StorageLive(_16);
          _16 = _1;
-         _17 = CheckedMul(_16, const 1_u64);
-         assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", move _16, const 1_u64) -> [success: bb7, unwind continue];
+         _17 = CheckedMul(_1, const 1_u64);
+         assert(!move (_17.1: bool), "attempt to compute `{} * {}`, which would overflow", _1, const 1_u64) -> [success: bb7, unwind continue];
      }
  
      bb7: {
          _15 = move (_17.0: u64);
          StorageDead(_16);
          _14 = opaque::<u64>(move _15) -> [return: bb8, unwind continue];
      }
  
      bb8: {
          StorageDead(_15);
          StorageDead(_14);
          _0 = const ();
          return;
      }
  }