- // MIR for `wide_ptr_ops` before GVN
+ // MIR for `wide_ptr_ops` after GVN
  
  fn wide_ptr_ops() -> () {
      let mut _0: ();
      let _1: *const dyn std::marker::Send;
      let mut _2: *const dyn std::marker::Send;
      let _3: &dyn std::marker::Send;
      let mut _4: &i32;
      let _5: &i32;
      let _6: i32;
      let mut _8: *const dyn std::marker::Send;
      let _9: &dyn std::marker::Send;
      let mut _10: &i32;
      let _11: &i32;
      let _12: i32;
      let mut _14: *const dyn std::marker::Send;
      let mut _15: *const dyn std::marker::Send;
      let mut _16: *const dyn std::marker::Send;
      let mut _18: *const dyn std::marker::Send;
      let mut _19: *const dyn std::marker::Send;
      let mut _20: *const dyn std::marker::Send;
      let mut _22: *const dyn std::marker::Send;
      let mut _23: *const dyn std::marker::Send;
      let mut _24: *const dyn std::marker::Send;
      let mut _26: *const dyn std::marker::Send;
      let mut _27: *const dyn std::marker::Send;
      let mut _28: *const dyn std::marker::Send;
      let mut _30: *const dyn std::marker::Send;
      let mut _31: *const dyn std::marker::Send;
      let mut _32: *const dyn std::marker::Send;
      let mut _34: *const dyn std::marker::Send;
      let mut _35: *const dyn std::marker::Send;
      let mut _36: *const dyn std::marker::Send;
      let mut _38: (usize, usize);
      let mut _40: (usize, usize);
      let _41: ();
      let mut _42: bool;
      let mut _43: bool;
      let mut _44: *const [u8];
      let mut _45: *const [u8];
      let _46: ();
      let mut _47: bool;
      let mut _48: *const [u8];
      let mut _49: *const [u8];
      let _50: ();
      let mut _51: bool;
      let mut _52: *const [u8];
      let mut _53: *const [u8];
      let _54: ();
      let mut _55: bool;
      let mut _56: *const [u8];
      let mut _57: *const [u8];
      let _58: ();
      let mut _59: bool;
      let mut _60: bool;
      let mut _61: *const [u8];
      let mut _62: *const [u8];
      let _63: ();
      let mut _64: bool;
      let mut _65: bool;
      let mut _66: *const [u8];
      let mut _67: *const [u8];
      let mut _69: &i32;
      scope 1 {
          debug a => _1;
          let _7: *const dyn std::marker::Send;
          let mut _68: &i32;
          scope 2 {
              debug b => _7;
              let _13: bool;
              scope 3 {
                  debug _val => _13;
                  let _17: bool;
                  scope 4 {
                      debug _val => _17;
                      let _21: bool;
                      scope 5 {
                          debug _val => _21;
                          let _25: bool;
                          scope 6 {
                              debug _val => _25;
                              let _29: bool;
                              scope 7 {
                                  debug _val => _29;
                                  let _33: bool;
                                  scope 8 {
                                      debug _val => _33;
                                      let _37: *const [u8];
                                      scope 9 {
                                          debug a => _37;
                                          let _39: *const [u8];
                                          scope 11 {
                                              debug b => _39;
                                          }
                                          scope 12 {
                                          }
                                      }
                                      scope 10 {
                                      }
                                  }
                              }
                          }
                      }
                  }
              }
          }
      }
  
      bb0: {
-         StorageLive(_1);
+         nop;
          StorageLive(_2);
          StorageLive(_3);
          StorageLive(_4);
          StorageLive(_5);
          _69 = const _;
          _5 = &(*_69);
          _4 = &(*_5);
          _3 = move _4 as &dyn std::marker::Send (PointerCoercion(Unsize));
          StorageDead(_4);
          _2 = &raw const (*_3);
          _1 = move _2 as *const dyn std::marker::Send (PointerCoercion(Unsize));
          StorageDead(_2);
          StorageDead(_5);
          StorageDead(_3);
-         StorageLive(_7);
+         nop;
          StorageLive(_8);
          StorageLive(_9);
          StorageLive(_10);
          StorageLive(_11);
          _68 = const _;
          _11 = &(*_68);
          _10 = &(*_11);
          _9 = move _10 as &dyn std::marker::Send (PointerCoercion(Unsize));
          StorageDead(_10);
          _8 = &raw const (*_9);
          _7 = move _8 as *const dyn std::marker::Send (PointerCoercion(Unsize));
          StorageDead(_8);
          StorageDead(_11);
          StorageDead(_9);
          StorageLive(_13);
          StorageLive(_14);
          _14 = _1;
-         StorageLive(_15);
+         nop;
          StorageLive(_16);
          _16 = _7;
-         _15 = move _16 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+         _15 = _7 as *const dyn std::marker::Send (PointerCoercion(Unsize));
          StorageDead(_16);
-         _13 = Eq(move _14, move _15);
-         StorageDead(_15);
+         _13 = Eq(_1, _15);
+         nop;
          StorageDead(_14);
          StorageLive(_17);
          StorageLive(_18);
          _18 = _1;
          StorageLive(_19);
          StorageLive(_20);
          _20 = _7;
-         _19 = move _20 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+         _19 = _15;
          StorageDead(_20);
-         _17 = Ne(move _18, move _19);
+         _17 = Ne(_1, _15);
          StorageDead(_19);
          StorageDead(_18);
          StorageLive(_21);
          StorageLive(_22);
          _22 = _1;
          StorageLive(_23);
          StorageLive(_24);
          _24 = _7;
-         _23 = move _24 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+         _23 = _15;
          StorageDead(_24);
-         _21 = Lt(move _22, move _23);
+         _21 = Lt(_1, _15);
          StorageDead(_23);
          StorageDead(_22);
          StorageLive(_25);
          StorageLive(_26);
          _26 = _1;
          StorageLive(_27);
          StorageLive(_28);
          _28 = _7;
-         _27 = move _28 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+         _27 = _15;
          StorageDead(_28);
-         _25 = Le(move _26, move _27);
+         _25 = Le(_1, _15);
          StorageDead(_27);
          StorageDead(_26);
          StorageLive(_29);
          StorageLive(_30);
          _30 = _1;
          StorageLive(_31);
          StorageLive(_32);
          _32 = _7;
-         _31 = move _32 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+         _31 = _15;
          StorageDead(_32);
-         _29 = Gt(move _30, move _31);
+         _29 = Gt(_1, _15);
          StorageDead(_31);
          StorageDead(_30);
          StorageLive(_33);
          StorageLive(_34);
          _34 = _1;
          StorageLive(_35);
          StorageLive(_36);
          _36 = _7;
-         _35 = move _36 as *const dyn std::marker::Send (PointerCoercion(Unsize));
+         _35 = _15;
          StorageDead(_36);
-         _33 = Ge(move _34, move _35);
+         _33 = Ge(_1, _15);
          StorageDead(_35);
          StorageDead(_34);
-         StorageLive(_37);
+         nop;
          StorageLive(_38);
-         _38 = (const 1_usize, const 1_usize);
-         _37 = move _38 as *const [u8] (Transmute);
+         _38 = const (1_usize, 1_usize);
+         _37 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
          StorageDead(_38);
-         StorageLive(_39);
+         nop;
          StorageLive(_40);
-         _40 = (const 1_usize, const 2_usize);
-         _39 = move _40 as *const [u8] (Transmute);
+         _40 = const (1_usize, 2_usize);
+         _39 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
          StorageDead(_40);
          StorageLive(_41);
-         StorageLive(_42);
+         nop;
          StorageLive(_43);
          StorageLive(_44);
-         _44 = _37;
+         _44 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
          StorageLive(_45);
-         _45 = _39;
-         _43 = Eq(move _44, move _45);
+         _45 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+         _43 = Eq(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
          StorageDead(_45);
          StorageDead(_44);
          _42 = Not(move _43);
          StorageDead(_43);
-         _41 = opaque::<bool>(move _42) -> [return: bb1, unwind unreachable];
+         _41 = opaque::<bool>(_42) -> [return: bb1, unwind unreachable];
      }
  
      bb1: {
-         StorageDead(_42);
+         nop;
          StorageDead(_41);
          StorageLive(_46);
          StorageLive(_47);
          StorageLive(_48);
-         _48 = _37;
+         _48 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
          StorageLive(_49);
-         _49 = _39;
-         _47 = Ne(move _48, move _49);
+         _49 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+         _47 = _42;
          StorageDead(_49);
          StorageDead(_48);
-         _46 = opaque::<bool>(move _47) -> [return: bb2, unwind unreachable];
+         _46 = opaque::<bool>(_42) -> [return: bb2, unwind unreachable];
      }
  
      bb2: {
          StorageDead(_47);
          StorageDead(_46);
          StorageLive(_50);
          StorageLive(_51);
          StorageLive(_52);
-         _52 = _37;
+         _52 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
          StorageLive(_53);
-         _53 = _39;
-         _51 = Le(move _52, move _53);
+         _53 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+         _51 = Le(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
          StorageDead(_53);
          StorageDead(_52);
          _50 = opaque::<bool>(move _51) -> [return: bb3, unwind unreachable];
      }
  
      bb3: {
          StorageDead(_51);
          StorageDead(_50);
          StorageLive(_54);
          StorageLive(_55);
          StorageLive(_56);
-         _56 = _37;
+         _56 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
          StorageLive(_57);
-         _57 = _39;
-         _55 = Lt(move _56, move _57);
+         _57 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+         _55 = Lt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
          StorageDead(_57);
          StorageDead(_56);
          _54 = opaque::<bool>(move _55) -> [return: bb4, unwind unreachable];
      }
  
      bb4: {
          StorageDead(_55);
          StorageDead(_54);
          StorageLive(_58);
          StorageLive(_59);
          StorageLive(_60);
          StorageLive(_61);
-         _61 = _37;
+         _61 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
          StorageLive(_62);
-         _62 = _39;
-         _60 = Ge(move _61, move _62);
+         _62 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+         _60 = Ge(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
          StorageDead(_62);
          StorageDead(_61);
          _59 = Not(move _60);
          StorageDead(_60);
          _58 = opaque::<bool>(move _59) -> [return: bb5, unwind unreachable];
      }
  
      bb5: {
          StorageDead(_59);
          StorageDead(_58);
          StorageLive(_63);
          StorageLive(_64);
          StorageLive(_65);
          StorageLive(_66);
-         _66 = _37;
+         _66 = const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8];
          StorageLive(_67);
-         _67 = _39;
-         _65 = Gt(move _66, move _67);
+         _67 = const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8];
+         _65 = Gt(const Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [u8], const Indirect { alloc_id: ALLOC1, offset: Size(0 bytes) }: *const [u8]);
          StorageDead(_67);
          StorageDead(_66);
          _64 = Not(move _65);
          StorageDead(_65);
          _63 = opaque::<bool>(move _64) -> [return: bb6, unwind unreachable];
      }
  
      bb6: {
          StorageDead(_64);
          StorageDead(_63);
          _0 = const ();
-         StorageDead(_39);
-         StorageDead(_37);
+         nop;
+         nop;
          StorageDead(_33);
          StorageDead(_29);
          StorageDead(_25);
          StorageDead(_21);
          StorageDead(_17);
          StorageDead(_13);
-         StorageDead(_7);
-         StorageDead(_1);
+         nop;
+         nop;
          return;
      }
+ }
+ 
+ ALLOC1 (size: 16, align: 8) {
+     01 00 00 00 00 00 00 00 02 00 00 00 00 00 00 00 │ ................
+ }
+ 
+ ALLOC0 (size: 16, align: 8) {
+     01 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 │ ................
  }