about summary refs log tree commit diff
path: root/tests
diff options
context:
space:
mode:
Diffstat (limited to 'tests')
-rw-r--r--tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff37
-rw-r--r--tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff37
-rw-r--r--tests/mir-opt/gvn.rs12
3 files changed, 77 insertions, 9 deletions
diff --git a/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff b/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff
index 161141ebc64..2b234637f4d 100644
--- a/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff
+++ b/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-abort.diff
@@ -14,11 +14,19 @@
       let _10: ();
       let mut _11: u16;
       let mut _12: TypedId<std::string::String>;
+      let mut _14: u16;
+      let _15: ();
+      let mut _16: u16;
+      let mut _17: std::result::Result<aggregate_struct_then_transmute::Never, u16>;
       scope 1 {
           debug a => _2;
           let _7: TypedId<std::string::String>;
           scope 2 {
               debug b => _7;
+              let _13: std::result::Result<aggregate_struct_then_transmute::Never, u16>;
+              scope 3 {
+                  debug c => _13;
+              }
           }
       }
   
@@ -62,19 +70,44 @@
 -         _12 = move _7;
 -         _11 = move _12 as u16 (Transmute);
 +         _12 = copy _7;
-+         _11 = copy _7 as u16 (Transmute);
++         _11 = copy _1;
           StorageDead(_12);
-          _10 = opaque::<u16>(move _11) -> [return: bb2, unwind unreachable];
+-         _10 = opaque::<u16>(move _11) -> [return: bb2, unwind unreachable];
++         _10 = opaque::<u16>(copy _1) -> [return: bb2, unwind unreachable];
       }
   
       bb2: {
           StorageDead(_11);
           StorageDead(_10);
+-         StorageLive(_13);
++         nop;
+          StorageLive(_14);
+          _14 = copy _1;
+-         _13 = Result::<Never, u16>::Err(move _14);
++         _13 = Result::<Never, u16>::Err(copy _1);
+          StorageDead(_14);
+          StorageLive(_15);
+          StorageLive(_16);
+          StorageLive(_17);
+-         _17 = move _13;
+-         _16 = move _17 as u16 (Transmute);
++         _17 = copy _13;
++         _16 = copy _1;
+          StorageDead(_17);
+-         _15 = opaque::<u16>(move _16) -> [return: bb3, unwind unreachable];
++         _15 = opaque::<u16>(copy _1) -> [return: bb3, unwind unreachable];
+      }
+  
+      bb3: {
+          StorageDead(_16);
+          StorageDead(_15);
           _0 = const ();
+-         StorageDead(_13);
 -         StorageDead(_7);
 -         StorageDead(_2);
 +         nop;
 +         nop;
++         nop;
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff b/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff
index a9d9f2c82c8..2f36a3c3939 100644
--- a/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff
+++ b/tests/mir-opt/gvn.aggregate_struct_then_transmute.GVN.panic-unwind.diff
@@ -14,11 +14,19 @@
       let _10: ();
       let mut _11: u16;
       let mut _12: TypedId<std::string::String>;
+      let mut _14: u16;
+      let _15: ();
+      let mut _16: u16;
+      let mut _17: std::result::Result<aggregate_struct_then_transmute::Never, u16>;
       scope 1 {
           debug a => _2;
           let _7: TypedId<std::string::String>;
           scope 2 {
               debug b => _7;
+              let _13: std::result::Result<aggregate_struct_then_transmute::Never, u16>;
+              scope 3 {
+                  debug c => _13;
+              }
           }
       }
   
@@ -62,19 +70,44 @@
 -         _12 = move _7;
 -         _11 = move _12 as u16 (Transmute);
 +         _12 = copy _7;
-+         _11 = copy _7 as u16 (Transmute);
++         _11 = copy _1;
           StorageDead(_12);
-          _10 = opaque::<u16>(move _11) -> [return: bb2, unwind continue];
+-         _10 = opaque::<u16>(move _11) -> [return: bb2, unwind continue];
++         _10 = opaque::<u16>(copy _1) -> [return: bb2, unwind continue];
       }
   
       bb2: {
           StorageDead(_11);
           StorageDead(_10);
+-         StorageLive(_13);
++         nop;
+          StorageLive(_14);
+          _14 = copy _1;
+-         _13 = Result::<Never, u16>::Err(move _14);
++         _13 = Result::<Never, u16>::Err(copy _1);
+          StorageDead(_14);
+          StorageLive(_15);
+          StorageLive(_16);
+          StorageLive(_17);
+-         _17 = move _13;
+-         _16 = move _17 as u16 (Transmute);
++         _17 = copy _13;
++         _16 = copy _1;
+          StorageDead(_17);
+-         _15 = opaque::<u16>(move _16) -> [return: bb3, unwind continue];
++         _15 = opaque::<u16>(copy _1) -> [return: bb3, unwind continue];
+      }
+  
+      bb3: {
+          StorageDead(_16);
+          StorageDead(_15);
           _0 = const ();
+-         StorageDead(_13);
 -         StorageDead(_7);
 -         StorageDead(_2);
 +         nop;
 +         nop;
++         nop;
           return;
       }
   }
diff --git a/tests/mir-opt/gvn.rs b/tests/mir-opt/gvn.rs
index 5fc252de0e5..3f9f0a0be37 100644
--- a/tests/mir-opt/gvn.rs
+++ b/tests/mir-opt/gvn.rs
@@ -938,13 +938,15 @@ unsafe fn aggregate_struct_then_transmute(id: u16) {
     let a = MyId(id);
     opaque(std::intrinsics::transmute::<_, u16>(a));
 
-    // GVN can't do this yet because it doesn't know which field is the ZST,
-    // but future changes might enable it.
-    // CHECK: [[AGG:_.+]] = TypedId::<String>(copy _1, const PhantomData::<String>);
-    // CHECK: [[INT:_.+]] = copy [[AGG]] as u16 (Transmute);
-    // CHECK: opaque::<u16>(move [[INT]])
+    // CHECK: opaque::<u16>(copy _1)
     let b = TypedId::<String>(id, PhantomData);
     opaque(std::intrinsics::transmute::<_, u16>(b));
+
+    // CHECK: opaque::<u16>(copy _1)
+    let c = Err::<Never, u16>(id);
+    opaque(std::intrinsics::transmute::<_, u16>(c));
+
+    enum Never {}
 }
 
 // Transmuting can skip a pointer cast so long as it wasn't a fat-to-thin cast.