GVN: Do not unify dereferences if they are references

dianqk · dianqk · commit 9c029d2102b7 · 2026-02-04T21:55:57.000+08:00
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
@@ -799,6 +799,18 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                     {
                         return Some((projection_ty, value));
                     }
+                    // DO NOT reason the pointer value.
+                    // We cannot unify two pointers that dereference same local, because they may
+                    // have different lifetimes.
+                    // ```
+                    // let b: &T = *a;
+                    // ... `a` is allowed to be modified. `c` and `b` have different borrowing lifetime.
+                    // Unifying them will extend the lifetime of `b`.
+                    // let c: &T = *a;
+                    // ```
+                    if projection_ty.ty.is_ref() {
+                        return None;
+                    }
 
                     // An immutable borrow `_x` always points to the same value for the
                     // lifetime of the borrow, so we can merge all instances of `*_x`.
diff --git a/tests/mir-opt/gvn.dereference_reborrow.GVN.panic-abort.diff b/tests/mir-opt/gvn.dereference_reborrow.GVN.panic-abort.diff
@@ -0,0 +1,37 @@
+- // MIR for `dereference_reborrow` before GVN
++ // MIR for `dereference_reborrow` after GVN
+  
+  fn dereference_reborrow(_1: &mut u8) -> () {
+      debug mut_a => _1;
+      let mut _0: ();
+      let _2: &u8;
+      scope 1 {
+          debug a => _2;
+          let _3: u8;
+          scope 2 {
+              debug b => _3;
+              let _4: u8;
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = &(*_1);
+-         StorageLive(_3);
++         nop;
+          _3 = copy (*_2);
+          StorageLive(_4);
+-         _4 = copy (*_2);
++         _4 = copy _3;
+          _0 = const ();
+          StorageDead(_4);
+-         StorageDead(_3);
++         nop;
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.dereference_reborrow.GVN.panic-unwind.diff b/tests/mir-opt/gvn.dereference_reborrow.GVN.panic-unwind.diff
@@ -0,0 +1,37 @@
+- // MIR for `dereference_reborrow` before GVN
++ // MIR for `dereference_reborrow` after GVN
+  
+  fn dereference_reborrow(_1: &mut u8) -> () {
+      debug mut_a => _1;
+      let mut _0: ();
+      let _2: &u8;
+      scope 1 {
+          debug a => _2;
+          let _3: u8;
+          scope 2 {
+              debug b => _3;
+              let _4: u8;
+              scope 3 {
+                  debug c => _4;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = &(*_1);
+-         StorageLive(_3);
++         nop;
+          _3 = copy (*_2);
+          StorageLive(_4);
+-         _4 = copy (*_2);
++         _4 = copy _3;
+          _0 = const ();
+          StorageDead(_4);
+-         StorageDead(_3);
++         nop;
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.field_borrow.GVN.panic-abort.diff b/tests/mir-opt/gvn.field_borrow.GVN.panic-abort.diff
@@ -0,0 +1,30 @@
+- // MIR for `field_borrow` before GVN
++ // MIR for `field_borrow` after GVN
+  
+  fn field_borrow(_1: &FieldBorrow<'_>) -> () {
+      debug a => _1;
+      let mut _0: ();
+      let _2: &u8;
+      scope 1 {
+          debug b => _2;
+          let _3: &u8;
+          scope 2 {
+              debug c => _3;
+          }
+      }
+  
+      bb0: {
+-         StorageLive(_2);
++         nop;
+          _2 = copy ((*_1).0: &u8);
+          StorageLive(_3);
+-         _3 = copy ((*_1).0: &u8);
++         _3 = copy _2;
+          _0 = const ();
+          StorageDead(_3);
+-         StorageDead(_2);
++         nop;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.field_borrow.GVN.panic-unwind.diff b/tests/mir-opt/gvn.field_borrow.GVN.panic-unwind.diff
@@ -0,0 +1,30 @@
+- // MIR for `field_borrow` before GVN
++ // MIR for `field_borrow` after GVN
+  
+  fn field_borrow(_1: &FieldBorrow<'_>) -> () {
+      debug a => _1;
+      let mut _0: ();
+      let _2: &u8;
+      scope 1 {
+          debug b => _2;
+          let _3: &u8;
+          scope 2 {
+              debug c => _3;
+          }
+      }
+  
+      bb0: {
+-         StorageLive(_2);
++         nop;
+          _2 = copy ((*_1).0: &u8);
+          StorageLive(_3);
+-         _3 = copy ((*_1).0: &u8);
++         _3 = copy _2;
+          _0 = const ();
+          StorageDead(_3);
+-         StorageDead(_2);
++         nop;
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.field_borrow_2.GVN.panic-abort.diff b/tests/mir-opt/gvn.field_borrow_2.GVN.panic-abort.diff
@@ -0,0 +1,51 @@
+- // MIR for `field_borrow_2` before GVN
++ // MIR for `field_borrow_2` after GVN
+  
+  fn field_borrow_2(_1: &&FieldBorrow<'_>) -> () {
+      debug a => _1;
+      let mut _0: ();
+      let _2: &FieldBorrow<'_>;
+      scope 1 {
+          debug b => _2;
+          let _3: &u8;
+          scope 2 {
+              debug c => _3;
+              let _4: &FieldBorrow<'_>;
+              scope 3 {
+                  debug d => _4;
+                  let _5: &u8;
+                  scope 4 {
+                      debug e => _5;
+                      let _6: &u8;
+                      scope 5 {
+                          debug f => _6;
+                      }
+                  }
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = copy (*_1);
+          StorageLive(_3);
+          _3 = copy ((*_2).0: &u8);
+          StorageLive(_4);
+          _4 = copy (*_1);
+-         StorageLive(_5);
++         nop;
+          _5 = copy ((*_4).0: &u8);
+          StorageLive(_6);
+-         _6 = copy ((*_4).0: &u8);
++         _6 = copy _5;
+          _0 = const ();
+          StorageDead(_6);
+-         StorageDead(_5);
++         nop;
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.field_borrow_2.GVN.panic-unwind.diff b/tests/mir-opt/gvn.field_borrow_2.GVN.panic-unwind.diff
@@ -0,0 +1,51 @@
+- // MIR for `field_borrow_2` before GVN
++ // MIR for `field_borrow_2` after GVN
+  
+  fn field_borrow_2(_1: &&FieldBorrow<'_>) -> () {
+      debug a => _1;
+      let mut _0: ();
+      let _2: &FieldBorrow<'_>;
+      scope 1 {
+          debug b => _2;
+          let _3: &u8;
+          scope 2 {
+              debug c => _3;
+              let _4: &FieldBorrow<'_>;
+              scope 3 {
+                  debug d => _4;
+                  let _5: &u8;
+                  scope 4 {
+                      debug e => _5;
+                      let _6: &u8;
+                      scope 5 {
+                          debug f => _6;
+                      }
+                  }
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_2);
+          _2 = copy (*_1);
+          StorageLive(_3);
+          _3 = copy ((*_2).0: &u8);
+          StorageLive(_4);
+          _4 = copy (*_1);
+-         StorageLive(_5);
++         nop;
+          _5 = copy ((*_4).0: &u8);
+          StorageLive(_6);
+-         _6 = copy ((*_4).0: &u8);
++         _6 = copy _5;
+          _0 = const ();
+          StorageDead(_6);
+-         StorageDead(_5);
++         nop;
+          StorageDead(_4);
+          StorageDead(_3);
+          StorageDead(_2);
+          return;
+      }
+  }
+  
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
@@ -1100,6 +1100,53 @@ fn dereference_indexing(array: [u8; 2], index: usize) {
     opaque(*a);
 }
 
+// EMIT_MIR gvn.dereference_reborrow.GVN.diff
+fn dereference_reborrow(mut_a: &mut u8) {
+    // CHECK-LABEL: fn dereference_reborrow(
+    // CHECK: debug a => [[a:_.*]];
+    // CHECK: debug b => [[b:_.*]];
+    // CHECK: debug c => [[c:_.*]];
+    // CHECK: [[a]] = &(*_1);
+    // CHECK: [[b]] = copy (*[[a]]);
+    // CHECK: [[c]] = copy [[b]];
+    let a = &*mut_a;
+    let b = *a;
+    let c = *a;
+}
+
+struct FieldBorrow<'a>(&'a u8);
+
+// EMIT_MIR gvn.field_borrow.GVN.diff
+fn field_borrow(a: &FieldBorrow<'_>) {
+    // CHECK-LABEL: fn field_borrow(
+    // CHECK: debug b => [[b:_.*]];
+    // CHECK: debug c => [[c:_.*]];
+    // CHECK: [[b]] = copy ((*_1).0: &u8);
+    // CHECK: [[c]] = copy [[b]];
+    let b = a.0;
+    let c = a.0;
+}
+
+// EMIT_MIR gvn.field_borrow_2.GVN.diff
+fn field_borrow_2(a: &&FieldBorrow<'_>) {
+    // CHECK-LABEL: fn field_borrow_2(
+    // CHECK: debug b => [[b:_.*]];
+    // CHECK: debug c => [[c:_.*]];
+    // CHECK: debug d => [[d:_.*]];
+    // CHECK: debug e => [[e:_.*]];
+    // CHECK: debug f => [[f:_.*]];
+    // CHECK: [[b]] = copy (*_1);
+    // CHECK: [[c]] = copy ((*[[b]]).0: &u8);
+    // CHECK: [[d]] = copy (*_1);
+    // CHECK: [[e]] = copy ((*[[d]]).0: &u8);
+    // CHECK: [[f]] = copy [[e]];
+    let b = *a;
+    let c = b.0;
+    let d = *a;
+    let e = d.0;
+    let f = d.0;
+}
+
 // CHECK-LABEL: fn main(
 fn main() {
     subexpression_elimination(2, 4, 5);
@@ -1129,6 +1176,9 @@ fn main() {
     meta_of_ref_to_slice(&42);
     slice_from_raw_parts_as_ptr(&123, 456);
     dereference_indexing([129, 14], 5);
+    dereference_reborrow(&mut 5);
+    field_borrow(&FieldBorrow(&0));
+    field_borrow(&&FieldBorrow(&0));
 }
 
 #[inline(never)]
diff --git a/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff b/tests/mir-opt/gvn_copy_aggregate.all_copy_2.GVN.diff
@@ -29,17 +29,13 @@
           _8 = copy (*_1);
           _2 = copy ((*_8).0: i32);
 -         StorageLive(_3);
--         _9 = copy (*_1);
--         _3 = copy ((*_9).1: u64);
--         StorageLive(_4);
--         _10 = copy (*_1);
--         _4 = copy ((*_10).2: [i8; 3]);
 +         nop;
-+         _9 = copy _8;
-+         _3 = copy ((*_8).1: u64);
+          _9 = copy (*_1);
+          _3 = copy ((*_9).1: u64);
+-         StorageLive(_4);
 +         nop;
-+         _10 = copy _8;
-+         _4 = copy ((*_8).2: [i8; 3]);
+          _10 = copy (*_1);
+          _4 = copy ((*_10).2: [i8; 3]);
           StorageLive(_5);
           _5 = copy _2;
           StorageLive(_6);
diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.rs b/tests/mir-opt/pre-codegen/deref_nested_borrows.rs
@@ -2,6 +2,17 @@
 
 fn src(x: &&u8) -> bool {
     // CHECK-LABEL: fn src(
+    // CHECK: debug y => [[Y:_.*]];
+    // CHECK: bb0:
+    // CHECK: [[BORROW_u8:_.*]] = copy (*_1);
+    // CHECK: [[Y]] = copy (*[[BORROW_u8]]);
+    // CHECK: bb1:
+    // BORROW_u8 outside its lifetime in bb1.
+    // CHECK-NOT: copy (*[[BORROW_u8]]);
+    // CHECK: copy (*_1);
+    // CHECK-NOT: _0 = const true;
+    // CHECK: _0 = Eq({{.*}}, {{.*}});
+    // CHECK-NOT: _0 = const true;
     let y = **x;
     unsafe { unknown() };
     **x == y
diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-abort.diff
@@ -24,14 +24,12 @@
   
       bb1: {
           StorageLive(_4);
--         _7 = copy (*_1);
--         _4 = copy (*_7);
-+         _7 = copy _6;
-+         _4 = copy _2;
+          _7 = copy (*_1);
+          _4 = copy (*_7);
           StorageLive(_5);
           _5 = copy _2;
 -         _0 = Eq(move _4, move _5);
-+         _0 = const true;
++         _0 = Eq(move _4, copy _2);
           StorageDead(_5);
           StorageDead(_4);
 -         StorageDead(_2);
diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.GVN.panic-unwind.diff
diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-abort.mir
diff --git a/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/deref_nested_borrows.src.PreCodegen.after.panic-unwind.mir
diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_a-{closure#0}.PreCodegen.after.mir
diff --git a/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/slice_filter.variant_b-{closure#0}.PreCodegen.after.mir
