tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff

- // MIR for `aggregate_struct_then_transmute` before GVN
+ // MIR for `aggregate_struct_then_transmute` after GVN
  
  fn aggregate_struct_then_transmute(_1: u16, _2: *const u8) -> () {
      debug id => _1;
      debug thin => _2;
      let mut _0: ();
      let _3: MyId;
      let mut _4: (u16) is 0..=55554;
      let mut _5: u16;
      let _6: ();
      let mut _7: u16;
      let mut _8: MyId;
      let mut _10: u16;
      let mut _11: std::marker::PhantomData<std::string::String>;
      let _12: ();
      let mut _13: u16;
      let mut _14: TypedId<std::string::String>;
      let mut _16: u16;
      let _17: ();
      let mut _18: u16;
      let mut _19: std::result::Result<Never, u16>;
      let mut _21: u16;
      let _22: ();
      let mut _23: u32;
      let mut _24: std::option::Option<u16>;
      let mut _26: (u16) is 0..=55554;
      let mut _27: u16;
      let _28: ();
      let mut _29: i16;
      let mut _30: MyId;
      let mut _32: u16;
      let mut _33: u16;
      let _34: ();
      let mut _35: u32;
      let mut _36: aggregate_struct_then_transmute::Pair;
      let mut _38: u16;
      let mut _39: u16;
      let _40: ();
      let mut _41: u16;
      let mut _42: aggregate_struct_then_transmute::Pair;
      let mut _44: u16;
      let _45: ();
      let mut _46: u16;
      let mut _47: (u16,);
      let mut _49: u16;
      let _50: ();
      let mut _51: u16;
      let mut _52: [u16; 1];
      let mut _54: *const u8;
      let mut _55: ();
      let _56: ();
      let mut _57: *const u8;
      let mut _58: *const i32;
      scope 1 {
          debug a => _3;
          let _9: TypedId<std::string::String>;
          scope 2 {
              debug b => _9;
              let _15: std::result::Result<Never, u16>;
              scope 3 {
                  debug c => _15;
                  let _20: std::option::Option<u16>;
                  scope 4 {
                      debug d => _20;
                      let _25: MyId;
                      scope 5 {
                          debug e => _25;
                          let _31: aggregate_struct_then_transmute::Pair;
                          scope 6 {
                              debug f => _31;
                              let _37: aggregate_struct_then_transmute::Pair;
                              scope 7 {
                                  debug g => _37;
                                  let _43: (u16,);
                                  scope 8 {
                                      debug h => _43;
                                      let _48: [u16; 1];
                                      scope 9 {
                                          debug i => _48;
                                          let _53: *const i32;
                                          scope 10 {
                                              debug j => _53;
                                          }
                                      }
                                  }
                              }
                          }
                      }
                  }
              }
          }
      }
  
      bb0: {
          StorageLive(_3);
-         StorageLive(_4);
+         nop;
          StorageLive(_5);
          _5 = copy _1;
-         _4 = move _5 as (u16) is 0..=55554 (Transmute);
+         _4 = copy _1 as (u16) is 0..=55554 (Transmute);
          StorageDead(_5);
-         _3 = MyId(move _4);
-         StorageDead(_4);
+         _3 = MyId(copy _4);
+         nop;
          StorageLive(_6);
          StorageLive(_7);
          StorageLive(_8);
-         _8 = move _3;
-         _7 = move _8 as u16 (Transmute);
+         _8 = copy _3;
+         _7 = copy _4 as u16 (Transmute);
          StorageDead(_8);
          _6 = opaque::<u16>(move _7) -> [return: bb1, unwind unreachable];
      }
  
      bb1: {
          StorageDead(_7);
          StorageDead(_6);
          StorageLive(_9);
          StorageLive(_10);
          _10 = copy _1;
          StorageLive(_11);
-         _11 = PhantomData::<String>;
-         _9 = TypedId::<String>(move _10, move _11);
+         _11 = const PhantomData::<String>;
+         _9 = TypedId::<String>(copy _1, const PhantomData::<String>);
          StorageDead(_11);
          StorageDead(_10);
          StorageLive(_12);
          StorageLive(_13);
          StorageLive(_14);
-         _14 = move _9;
-         _13 = move _14 as u16 (Transmute);
+         _14 = copy _9;
+         _13 = copy _1;
          StorageDead(_14);
-         _12 = opaque::<u16>(move _13) -> [return: bb2, unwind unreachable];
+         _12 = opaque::<u16>(copy _1) -> [return: bb2, unwind unreachable];
      }
  
      bb2: {
          StorageDead(_13);
          StorageDead(_12);
          StorageLive(_15);
          StorageLive(_16);
          _16 = copy _1;
-         _15 = Result::<Never, u16>::Err(move _16);
+         _15 = Result::<Never, u16>::Err(copy _1);
          StorageDead(_16);
          StorageLive(_17);
          StorageLive(_18);
          StorageLive(_19);
-         _19 = move _15;
-         _18 = move _19 as u16 (Transmute);
+         _19 = copy _15;
+         _18 = copy _1;
          StorageDead(_19);
-         _17 = opaque::<u16>(move _18) -> [return: bb3, unwind unreachable];
+         _17 = opaque::<u16>(copy _1) -> [return: bb3, unwind unreachable];
      }
  
      bb3: {
          StorageDead(_18);
          StorageDead(_17);
          StorageLive(_20);
          StorageLive(_21);
          _21 = copy _1;
-         _20 = Option::<u16>::Some(move _21);
+         _20 = Option::<u16>::Some(copy _1);
          StorageDead(_21);
          StorageLive(_22);
          StorageLive(_23);
          StorageLive(_24);
          _24 = copy _20;
-         _23 = move _24 as u32 (Transmute);
+         _23 = copy _20 as u32 (Transmute);
          StorageDead(_24);
          _22 = opaque::<u32>(move _23) -> [return: bb4, unwind unreachable];
      }
  
      bb4: {
          StorageDead(_23);
          StorageDead(_22);
          StorageLive(_25);
          StorageLive(_26);
          StorageLive(_27);
          _27 = copy _1;
-         _26 = move _27 as (u16) is 0..=55554 (Transmute);
+         _26 = copy _4;
          StorageDead(_27);
-         _25 = MyId(move _26);
+         _25 = copy _3;
          StorageDead(_26);
          StorageLive(_28);
          StorageLive(_29);
          StorageLive(_30);
-         _30 = move _25;
-         _29 = move _30 as i16 (Transmute);
+         _30 = copy _3;
+         _29 = copy _4 as i16 (Transmute);
          StorageDead(_30);
          _28 = opaque::<i16>(move _29) -> [return: bb5, unwind unreachable];
      }
  
      bb5: {
          StorageDead(_29);
          StorageDead(_28);
          StorageLive(_31);
          StorageLive(_32);
          _32 = copy _1;
          StorageLive(_33);
          _33 = copy _1;
-         _31 = Pair(move _32, move _33);
+         _31 = Pair(copy _1, copy _1);
          StorageDead(_33);
          StorageDead(_32);
          StorageLive(_34);
          StorageLive(_35);
          StorageLive(_36);
-         _36 = move _31;
-         _35 = move _36 as u32 (Transmute);
+         _36 = copy _31;
+         _35 = copy _31 as u32 (Transmute);
          StorageDead(_36);
          _34 = opaque::<u32>(move _35) -> [return: bb6, unwind unreachable];
      }
  
      bb6: {
          StorageDead(_35);
          StorageDead(_34);
          StorageLive(_37);
          StorageLive(_38);
          _38 = copy _1;
          StorageLive(_39);
          _39 = copy _1;
-         _37 = Pair(move _38, move _39);
+         _37 = copy _31;
          StorageDead(_39);
          StorageDead(_38);
          StorageLive(_40);
          StorageLive(_41);
          StorageLive(_42);
-         _42 = move _37;
-         _41 = move _42 as u16 (Transmute);
+         _42 = copy _31;
+         _41 = copy _31 as u16 (Transmute);
          StorageDead(_42);
          _40 = opaque::<u16>(move _41) -> [return: bb7, unwind unreachable];
      }
  
      bb7: {
          StorageDead(_41);
          StorageDead(_40);
          StorageLive(_43);
          StorageLive(_44);
          _44 = copy _1;
-         _43 = (move _44,);
+         _43 = (copy _1,);
          StorageDead(_44);
          StorageLive(_45);
          StorageLive(_46);
          StorageLive(_47);
          _47 = copy _43;
-         _46 = move _47 as u16 (Transmute);
+         _46 = copy _1;
          StorageDead(_47);
-         _45 = opaque::<u16>(move _46) -> [return: bb8, unwind unreachable];
+         _45 = opaque::<u16>(copy _1) -> [return: bb8, unwind unreachable];
      }
  
      bb8: {
          StorageDead(_46);
          StorageDead(_45);
          StorageLive(_48);
          StorageLive(_49);
          _49 = copy _1;
-         _48 = [move _49];
+         _48 = [copy _1];
          StorageDead(_49);
          StorageLive(_50);
          StorageLive(_51);
          StorageLive(_52);
          _52 = copy _48;
-         _51 = move _52 as u16 (Transmute);
+         _51 = copy _1;
          StorageDead(_52);
-         _50 = opaque::<u16>(move _51) -> [return: bb9, unwind unreachable];
+         _50 = opaque::<u16>(copy _1) -> [return: bb9, unwind unreachable];
      }
  
      bb9: {
          StorageDead(_51);
          StorageDead(_50);
          StorageLive(_53);
          StorageLive(_54);
          _54 = copy _2;
          StorageLive(_55);
-         _55 = ();
-         _53 = *const i32 from (move _54, move _55);
+         _55 = const ();
+         _53 = *const i32 from (copy _2, const ());
          StorageDead(_55);
          StorageDead(_54);
          StorageLive(_56);
          StorageLive(_57);
          StorageLive(_58);
          _58 = copy _53;
-         _57 = move _58 as *const u8 (Transmute);
+         _57 = copy _2;
          StorageDead(_58);
-         _56 = opaque::<*const u8>(move _57) -> [return: bb10, unwind unreachable];
+         _56 = opaque::<*const u8>(copy _2) -> [return: bb10, unwind unreachable];
      }
  
      bb10: {
          StorageDead(_57);
          StorageDead(_56);
          _0 = const ();
          StorageDead(_53);
          StorageDead(_48);
          StorageDead(_43);
          StorageDead(_37);
          StorageDead(_31);
          StorageDead(_25);
          StorageDead(_20);
          StorageDead(_15);
          StorageDead(_9);
          StorageDead(_3);
          return;
      }
  }