Add miscompiled test cases for GVN

Author: dianqk

tests/mir-opt/gvn_copy_aggregate.deref_nonssa.GVN.diff

@@ -0,0 +1,50 @@
+- // MIR for `deref_nonssa` before GVN
++ // MIR for `deref_nonssa` after GVN
+  
+  fn deref_nonssa() -> Single {
+      let mut _0: Single;
+      let mut _1: Single;
+      let mut _4: Single;
+      let mut _5: u8;
+      scope 1 {
+          debug a => _1;
+          let _2: &Single;
+          scope 2 {
+              debug b => _2;
+              let _3: u8;
+              scope 3 {
+                  debug c => _3;
+              }
+          }
+      }
+  
+      bb0: {
+          StorageLive(_1);
+-         _1 = Single(const 0_u8);
+-         StorageLive(_2);
++         _1 = const Single(0_u8);
++         nop;
+          _2 = &_1;
+-         StorageLive(_3);
++         nop;
+          _3 = copy ((*_2).0: u8);
+          StorageLive(_4);
+-         _4 = Single(const 1_u8);
+-         _1 = move _4;
++         _4 = const Single(1_u8);
++         _1 = const Single(1_u8);
+          StorageDead(_4);
+          StorageLive(_5);
+          _5 = copy _3;
+-         _0 = Single(move _5);
++         _0 = copy (*_2);
+          StorageDead(_5);
+-         StorageDead(_3);
+-         StorageDead(_2);
++         nop;
++         nop;
+          StorageDead(_1);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn_copy_aggregate.rs

@@ -259,3 +259,15 @@ fn remove_storage_dead_from_index(f: fn() -> usize, v: [SameType; 5]) -> SameTyp
         }
     }
 }
+
+pub struct Single(u8);
+
+// EMIT_MIR gvn_copy_aggregate.deref_nonssa.GVN.diff
+fn deref_nonssa() -> Single {
+    let mut a = Single(0);
+    let b = &a;
+    let c = (*b).0;
+    a = Single(1);
+    // GVN shouldn't replace `Single(c)` with `*b`.
+    Single(c)
+}

tests/mir-opt/gvn_overlapping.copy_overlapping.GVN.diff

@@ -0,0 +1,19 @@
+- // MIR for `copy_overlapping` before GVN
++ // MIR for `copy_overlapping` after GVN
+  
+  fn copy_overlapping() -> () {
+      let mut _0: ();
+      let mut _1: Adt;
+      let mut _2: u32;
+      let mut _3: &Adt;
+  
+      bb0: {
+          ((_1 as variant#1).0: u32) = const 0_u32;
+          _3 = &_1;
+          _2 = copy (((*_3) as variant#1).0: u32);
+-         _1 = Adt::Some(copy _2);
++         _1 = copy (*_3);
+          return;
+      }
+  }
+  

tests/mir-opt/gvn_overlapping.rs

@@ -64,6 +64,23 @@ fn fields(_1: (Adt, Adt)) {
     }
 }
 
+// EMIT_MIR gvn_overlapping.copy_overlapping.GVN.diff
+#[custom_mir(dialect = "runtime")]
+fn copy_overlapping() {
+    mir! {
+        let _1;
+        let _2;
+        let _3;
+        {
+            place!(Field(Variant(_1, 1), 0)) = 0u32;
+            _3 = &_1;
+            _2 = Field(Variant(*_3, 1), 0);
+            _1 = Adt::Some(_2);
+            Return()
+        }
+    }
+}
+
 fn main() {
     overlapping(Adt::Some(0));
 }