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

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