rust/tests/mir-opt/reference_prop.reference_propagation_mut_ptr.ReferencePropagation.diff

- // MIR for `reference_propagation_mut_ptr` before ReferencePropagation
+ // MIR for `reference_propagation_mut_ptr` after ReferencePropagation
  
  fn reference_propagation_mut_ptr(_1: *mut T, _2: *mut T) -> () {
      debug single => _1;
      debug multiple => _2;
      let mut _0: ();
      let _3: ();
      let _7: ();
      let mut _8: ();
      let _9: ();
      let mut _13: *mut usize;
      let _15: ();
      let mut _16: ();
      let _17: ();
      let _22: ();
      let mut _23: &*mut usize;
      let _24: ();
      let _29: ();
      let mut _30: *mut *mut usize;
      let _31: ();
      let _35: ();
      let mut _36: *mut usize;
      let _37: ();
      let _44: ();
      let mut _45: *mut usize;
      let _46: ();
      let _49: ();
      let mut _50: ();
      let _51: ();
      let mut _53: *mut T;
      let _55: ();
      let mut _56: ();
      let _57: ();
      let _62: ();
      let mut _63: ();
      let _68: ();
      let mut _69: ();
      scope 1 {
          let mut _4: usize;
          scope 2 {
              debug a => _4;
              let _5: *mut usize;
              scope 3 {
-                 debug b => _5;
+                 debug b => &_4;
                  let _6: usize;
                  scope 4 {
                      debug c => _6;
                  }
              }
          }
      }
      scope 5 {
          let mut _10: usize;
          scope 6 {
              debug a => _10;
              let mut _11: usize;
              scope 7 {
                  debug a2 => _11;
                  let mut _12: *mut usize;
                  scope 8 {
                      debug b => _12;
                      let _14: usize;
                      scope 9 {
                          debug c => _14;
                      }
                  }
              }
          }
      }
      scope 10 {
          let mut _18: usize;
          scope 11 {
              debug a => _18;
              let _19: *mut usize;
              scope 12 {
                  debug b => _19;
                  let _20: &*mut usize;
                  scope 13 {
                      debug d => _20;
                      let _21: usize;
                      scope 14 {
                          debug c => _21;
                      }
                  }
              }
          }
      }
      scope 15 {
          let mut _25: usize;
          scope 16 {
              debug a => _25;
              let mut _26: *mut usize;
              scope 17 {
                  debug b => _26;
                  let _27: *mut *mut usize;
                  scope 18 {
                      debug d => _27;
                      let _28: usize;
                      scope 19 {
                          debug c => _28;
                      }
                  }
              }
          }
      }
      scope 20 {
          let mut _32: usize;
          scope 21 {
              debug a => _32;
              let _33: *mut usize;
              scope 22 {
                  debug b => _33;
                  let _34: usize;
                  scope 23 {
                      debug c => _34;
                  }
              }
          }
      }
      scope 24 {
          let mut _38: usize;
          scope 25 {
              debug a => _38;
              let _39: *mut usize;
              scope 26 {
                  debug b1 => _39;
                  let _40: usize;
                  scope 27 {
                      debug c => _40;
                      let _41: *mut usize;
                      scope 28 {
                          debug b2 => _41;
                          let _42: usize;
                          scope 29 {
                              debug c2 => _42;
                              let _43: *mut usize;
                              scope 30 {
                                  debug b3 => _43;
                              }
                          }
                      }
                  }
              }
          }
      }
      scope 31 {
          let _47: *mut T;
          scope 32 {
-             debug a => _47;
+             debug a => _1;
              let _48: T;
              scope 33 {
                  debug b => _48;
              }
          }
      }
      scope 34 {
          let _52: *mut T;
          scope 35 {
              debug a => _52;
              let _54: T;
              scope 36 {
                  debug b => _54;
              }
          }
      }
      scope 37 {
          let mut _58: usize;
          scope 38 {
              debug a => _58;
              let _59: *mut usize;
              scope 39 {
-                 debug b => _59;
+                 debug b => &_58;
                  let _60: &*mut usize;
                  scope 40 {
-                     debug d => _60;
+                     debug d => &&_58;
                      let _61: usize;
                      scope 41 {
                          debug c => _61;
                      }
                  }
              }
          }
      }
      scope 42 {
          let mut _64: usize;
          scope 43 {
              debug a => _64;
              let mut _65: *mut usize;
              scope 44 {
-                 debug b => _65;
+                 debug b => &_64;
                  let _66: &mut *mut usize;
                  scope 45 {
-                     debug d => _66;
+                     debug d => &&_64;
                      let _67: usize;
                      scope 46 {
                          debug c => _67;
                      }
                  }
              }
          }
      }
  
      bb0: {
-         StorageLive(_3);
          StorageLive(_4);
          _4 = const 5_usize;
-         StorageLive(_5);
-         _5 = &raw mut _4;
          StorageLive(_6);
-         _6 = (*_5);
+         _6 = _4;
          StorageLive(_7);
          StorageLive(_8);
          _8 = ();
          _7 = opaque::<()>(move _8) -> [return: bb1, unwind continue];
      }
  
      bb1: {
          StorageDead(_8);
          StorageDead(_7);
-         _3 = const ();
          StorageDead(_6);
-         StorageDead(_5);
          StorageDead(_4);
-         StorageDead(_3);
-         StorageLive(_9);
          StorageLive(_10);
          _10 = const 5_usize;
          StorageLive(_11);
          _11 = const 7_usize;
          StorageLive(_12);
          _12 = &raw mut _10;
          StorageLive(_13);
          _13 = &raw mut _11;
          _12 = move _13;
          StorageDead(_13);
          StorageLive(_14);
          _14 = (*_12);
          StorageLive(_15);
          StorageLive(_16);
          _16 = ();
          _15 = opaque::<()>(move _16) -> [return: bb2, unwind continue];
      }
  
      bb2: {
          StorageDead(_16);
          StorageDead(_15);
-         _9 = const ();
          StorageDead(_14);
          StorageDead(_12);
          StorageDead(_11);
          StorageDead(_10);
-         StorageDead(_9);
-         StorageLive(_17);
          StorageLive(_18);
          _18 = const 5_usize;
          StorageLive(_19);
          _19 = &raw mut _18;
          StorageLive(_20);
          _20 = &_19;
          StorageLive(_21);
          _21 = (*_19);
          StorageLive(_22);
          StorageLive(_23);
          _23 = _20;
          _22 = opaque::<&*mut usize>(move _23) -> [return: bb3, unwind continue];
      }
  
      bb3: {
          StorageDead(_23);
          StorageDead(_22);
-         _17 = const ();
          StorageDead(_21);
          StorageDead(_20);
          StorageDead(_19);
          StorageDead(_18);
-         StorageDead(_17);
-         StorageLive(_24);
          StorageLive(_25);
          _25 = const 5_usize;
          StorageLive(_26);
          _26 = &raw mut _25;
          StorageLive(_27);
          _27 = &raw mut _26;
          StorageLive(_28);
          _28 = (*_26);
          StorageLive(_29);
          StorageLive(_30);
          _30 = _27;
          _29 = opaque::<*mut *mut usize>(move _30) -> [return: bb4, unwind continue];
      }
  
      bb4: {
          StorageDead(_30);
          StorageDead(_29);
-         _24 = const ();
          StorageDead(_28);
          StorageDead(_27);
          StorageDead(_26);
          StorageDead(_25);
-         StorageDead(_24);
-         StorageLive(_31);
          StorageLive(_32);
          _32 = const 7_usize;
          StorageLive(_33);
          _33 = &raw mut _32;
          StorageLive(_34);
          _34 = (*_33);
          StorageLive(_35);
          StorageLive(_36);
          _36 = _33;
          _35 = opaque::<*mut usize>(move _36) -> [return: bb5, unwind continue];
      }
  
      bb5: {
          StorageDead(_36);
          StorageDead(_35);
-         _31 = const ();
          StorageDead(_34);
          StorageDead(_33);
          StorageDead(_32);
-         StorageDead(_31);
-         StorageLive(_37);
          StorageLive(_38);
          _38 = const 7_usize;
          StorageLive(_39);
          _39 = &raw mut _38;
          StorageLive(_40);
          _40 = (*_39);
          StorageLive(_41);
          _41 = _39;
          StorageLive(_42);
          _42 = (*_41);
          StorageLive(_43);
          _43 = _41;
          StorageLive(_44);
          StorageLive(_45);
          _45 = _43;
          _44 = opaque::<*mut usize>(move _45) -> [return: bb6, unwind continue];
      }
  
      bb6: {
          StorageDead(_45);
          StorageDead(_44);
-         _37 = const ();
          StorageDead(_43);
          StorageDead(_42);
          StorageDead(_41);
          StorageDead(_40);
          StorageDead(_39);
          StorageDead(_38);
-         StorageDead(_37);
-         StorageLive(_46);
-         StorageLive(_47);
-         _47 = &raw mut (*_1);
          StorageLive(_48);
-         _48 = (*_47);
+         _48 = (*_1);
          StorageLive(_49);
          StorageLive(_50);
          _50 = ();
          _49 = opaque::<()>(move _50) -> [return: bb7, unwind continue];
      }
  
      bb7: {
          StorageDead(_50);
          StorageDead(_49);
-         _46 = const ();
          StorageDead(_48);
-         StorageDead(_47);
-         StorageDead(_46);
-         StorageLive(_51);
          StorageLive(_52);
          _52 = &raw mut (*_2);
          StorageLive(_53);
          _53 = &raw mut (*_1);
          _2 = move _53;
          StorageDead(_53);
          StorageLive(_54);
          _54 = (*_52);
          StorageLive(_55);
          StorageLive(_56);
          _56 = ();
          _55 = opaque::<()>(move _56) -> [return: bb8, unwind continue];
      }
  
      bb8: {
          StorageDead(_56);
          StorageDead(_55);
-         _51 = const ();
          StorageDead(_54);
          StorageDead(_52);
-         StorageDead(_51);
-         StorageLive(_57);
          StorageLive(_58);
          _58 = const 5_usize;
-         StorageLive(_59);
-         _59 = &raw mut _58;
-         StorageLive(_60);
-         _60 = &_59;
          StorageLive(_61);
-         _61 = (*_59);
+         _61 = _58;
          StorageLive(_62);
          StorageLive(_63);
          _63 = ();
          _62 = opaque::<()>(move _63) -> [return: bb9, unwind continue];
      }
  
      bb9: {
          StorageDead(_63);
          StorageDead(_62);
-         _57 = const ();
          StorageDead(_61);
-         StorageDead(_60);
-         StorageDead(_59);
          StorageDead(_58);
-         StorageDead(_57);
          StorageLive(_64);
          _64 = const 5_usize;
-         StorageLive(_65);
-         _65 = &raw mut _64;
-         StorageLive(_66);
-         _66 = &mut _65;
          StorageLive(_67);
-         _67 = (*_65);
+         _67 = _64;
          StorageLive(_68);
          StorageLive(_69);
          _69 = ();
          _68 = opaque::<()>(move _69) -> [return: bb10, unwind continue];
      }
  
      bb10: {
          StorageDead(_69);
          StorageDead(_68);
          _0 = const ();
          StorageDead(_67);
-         StorageDead(_66);
-         StorageDead(_65);
          StorageDead(_64);
          return;
      }
  }