rust/tests/mir-opt/gvn.slices.GVN.panic-abort.diff

- // MIR for `slices` before GVN
+ // MIR for `slices` after GVN
  
  fn slices() -> () {
      let mut _0: ();
      let _1: &str;
      let _2: ();
      let mut _3: &str;
      let _5: ();
      let mut _6: &str;
      let _7: ();
      let mut _8: (&*const u8, &*const u8);
      let mut _9: &*const u8;
      let _10: *const u8;
      let mut _11: &str;
      let mut _12: &*const u8;
      let _13: *const u8;
      let mut _14: &str;
      let mut _17: bool;
      let mut _18: *const u8;
      let mut _19: *const u8;
      let mut _20: !;
      let _22: !;
      let mut _23: core::panicking::AssertKind;
      let mut _24: &*const u8;
      let _25: &*const u8;
      let mut _26: &*const u8;
      let _27: &*const u8;
      let mut _28: std::option::Option<std::fmt::Arguments<'_>>;
      let mut _30: &str;
      let _31: ();
      let mut _32: &[u8];
      let _33: ();
      let mut _34: (&*const u8, &*const u8);
      let mut _35: &*const u8;
      let _36: *const u8;
      let mut _37: &str;
      let mut _38: &*const u8;
      let _39: *const u8;
      let mut _40: &[u8];
      let mut _43: bool;
      let mut _44: *const u8;
      let mut _45: *const u8;
      let mut _46: !;
      let _48: !;
      let mut _49: core::panicking::AssertKind;
      let mut _50: &*const u8;
      let _51: &*const u8;
      let mut _52: &*const u8;
      let _53: &*const u8;
      let mut _54: std::option::Option<std::fmt::Arguments<'_>>;
      scope 1 {
          debug s => _1;
          let _4: &str;
          scope 2 {
              debug t => _4;
              let _15: &*const u8;
              let _16: &*const u8;
              let _29: &[u8];
              scope 3 {
                  debug left_val => _15;
                  debug right_val => _16;
                  let _21: core::panicking::AssertKind;
                  scope 4 {
                      debug kind => _21;
                  }
              }
              scope 5 {
                  debug u => _29;
                  let _41: &*const u8;
                  let _42: &*const u8;
                  scope 6 {
                      debug left_val => _41;
                      debug right_val => _42;
                      let _47: core::panicking::AssertKind;
                      scope 7 {
                          debug kind => _47;
                      }
                  }
              }
          }
      }
  
      bb0: {
-         StorageLive(_1);
+         nop;
          _1 = const "my favourite slice";
          StorageLive(_2);
          StorageLive(_3);
          _3 = copy _1;
-         _2 = opaque::<&str>(move _3) -> [return: bb1, unwind unreachable];
+         _2 = opaque::<&str>(copy _1) -> [return: bb1, unwind unreachable];
      }
  
      bb1: {
          StorageDead(_3);
          StorageDead(_2);
          StorageLive(_4);
          _4 = copy _1;
          StorageLive(_5);
          StorageLive(_6);
-         _6 = copy _4;
-         _5 = opaque::<&str>(move _6) -> [return: bb2, unwind unreachable];
+         _6 = copy _1;
+         _5 = opaque::<&str>(copy _1) -> [return: bb2, unwind unreachable];
      }
  
      bb2: {
          StorageDead(_6);
          StorageDead(_5);
          StorageLive(_7);
          StorageLive(_8);
-         StorageLive(_9);
-         StorageLive(_10);
+         nop;
+         nop;
          StorageLive(_11);
          _11 = &(*_1);
          _10 = core::str::<impl str>::as_ptr(move _11) -> [return: bb3, unwind unreachable];
      }
  
      bb3: {
          StorageDead(_11);
          _9 = &_10;
-         StorageLive(_12);
-         StorageLive(_13);
+         nop;
+         nop;
          StorageLive(_14);
-         _14 = &(*_4);
+         _14 = &(*_1);
          _13 = core::str::<impl str>::as_ptr(move _14) -> [return: bb4, unwind unreachable];
      }
  
      bb4: {
          StorageDead(_14);
          _12 = &_13;
-         _8 = (move _9, move _12);
-         StorageDead(_12);
-         StorageDead(_9);
+         _8 = (copy _9, copy _12);
+         nop;
+         nop;
          StorageLive(_15);
-         _15 = copy (_8.0: &*const u8);
+         _15 = copy _9;
          StorageLive(_16);
-         _16 = copy (_8.1: &*const u8);
+         _16 = copy _12;
          StorageLive(_17);
          StorageLive(_18);
-         _18 = copy (*_15);
+         _18 = copy _10;
          StorageLive(_19);
-         _19 = copy (*_16);
-         _17 = Eq(move _18, move _19);
+         _19 = copy _13;
+         _17 = Eq(copy _10, copy _13);
          switchInt(move _17) -> [0: bb6, otherwise: bb5];
      }
  
      bb5: {
          StorageDead(_19);
          StorageDead(_18);
          _7 = const ();
          StorageDead(_17);
          StorageDead(_16);
          StorageDead(_15);
-         StorageDead(_13);
-         StorageDead(_10);
+         nop;
+         nop;
          StorageDead(_8);
          StorageDead(_7);
-         StorageLive(_29);
+         nop;
          StorageLive(_30);
          _30 = &(*_1);
          _29 = move _30 as &[u8] (Transmute);
          StorageDead(_30);
          StorageLive(_31);
          StorageLive(_32);
          _32 = copy _29;
-         _31 = opaque::<&[u8]>(move _32) -> [return: bb7, unwind unreachable];
+         _31 = opaque::<&[u8]>(copy _29) -> [return: bb7, unwind unreachable];
      }
  
      bb6: {
          StorageDead(_19);
          StorageDead(_18);
-         StorageLive(_21);
-         _21 = core::panicking::AssertKind::Eq;
+         nop;
+         _21 = const core::panicking::AssertKind::Eq;
          StorageLive(_22);
          StorageLive(_23);
-         _23 = move _21;
+         _23 = const core::panicking::AssertKind::Eq;
          StorageLive(_24);
          StorageLive(_25);
-         _25 = &(*_15);
+         _25 = &(*_9);
          _24 = &(*_25);
          StorageLive(_26);
          StorageLive(_27);
-         _27 = &(*_16);
+         _27 = &(*_12);
          _26 = &(*_27);
          StorageLive(_28);
          _28 = Option::<Arguments<'_>>::None;
-         _22 = assert_failed::<*const u8, *const u8>(move _23, move _24, move _26, move _28) -> unwind unreachable;
+         _22 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _24, move _26, move _28) -> unwind unreachable;
      }
  
      bb7: {
          StorageDead(_32);
          StorageDead(_31);
          StorageLive(_33);
          StorageLive(_34);
-         StorageLive(_35);
-         StorageLive(_36);
+         nop;
+         nop;
          StorageLive(_37);
          _37 = &(*_1);
          _36 = core::str::<impl str>::as_ptr(move _37) -> [return: bb8, unwind unreachable];
      }
  
      bb8: {
          StorageDead(_37);
          _35 = &_36;
-         StorageLive(_38);
-         StorageLive(_39);
+         nop;
+         nop;
          StorageLive(_40);
          _40 = &(*_29);
          _39 = core::slice::<impl [u8]>::as_ptr(move _40) -> [return: bb9, unwind unreachable];
      }
  
      bb9: {
          StorageDead(_40);
          _38 = &_39;
-         _34 = (move _35, move _38);
-         StorageDead(_38);
-         StorageDead(_35);
+         _34 = (copy _35, copy _38);
+         nop;
+         nop;
          StorageLive(_41);
-         _41 = copy (_34.0: &*const u8);
+         _41 = copy _35;
          StorageLive(_42);
-         _42 = copy (_34.1: &*const u8);
+         _42 = copy _38;
          StorageLive(_43);
          StorageLive(_44);
-         _44 = copy (*_41);
+         _44 = copy _36;
          StorageLive(_45);
-         _45 = copy (*_42);
-         _43 = Eq(move _44, move _45);
+         _45 = copy _39;
+         _43 = Eq(copy _36, copy _39);
          switchInt(move _43) -> [0: bb11, otherwise: bb10];
      }
  
      bb10: {
          StorageDead(_45);
          StorageDead(_44);
          _33 = const ();
          StorageDead(_43);
          StorageDead(_42);
          StorageDead(_41);
-         StorageDead(_39);
-         StorageDead(_36);
+         nop;
+         nop;
          StorageDead(_34);
          StorageDead(_33);
          _0 = const ();
-         StorageDead(_29);
+         nop;
          StorageDead(_4);
-         StorageDead(_1);
+         nop;
          return;
      }
  
      bb11: {
          StorageDead(_45);
          StorageDead(_44);
-         StorageLive(_47);
-         _47 = core::panicking::AssertKind::Eq;
+         nop;
+         _47 = const core::panicking::AssertKind::Eq;
          StorageLive(_48);
          StorageLive(_49);
-         _49 = move _47;
+         _49 = const core::panicking::AssertKind::Eq;
          StorageLive(_50);
          StorageLive(_51);
-         _51 = &(*_41);
+         _51 = &(*_35);
          _50 = &(*_51);
          StorageLive(_52);
          StorageLive(_53);
-         _53 = &(*_42);
+         _53 = &(*_38);
          _52 = &(*_53);
          StorageLive(_54);
          _54 = Option::<Arguments<'_>>::None;
-         _48 = assert_failed::<*const u8, *const u8>(move _49, move _50, move _52, move _54) -> unwind unreachable;
+         _48 = assert_failed::<*const u8, *const u8>(const core::panicking::AssertKind::Eq, move _50, move _52, move _54) -> unwind unreachable;
      }
  }