Auto merge of #153085 - oli-obk:transmute_project, r=<try>

GVN: transmute adts to their fields if a field projection is immediately transmuted anyway

Author: bors

compiler/rustc_mir_transform/src/gvn.rs

@@ -1494,6 +1494,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
         }
     }
 
+    #[instrument(level = "trace", skip(self), ret)]
     fn simplify_cast(
         &mut self,
         initial_kind: &mut CastKind,
@@ -1549,6 +1550,38 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 }
             }
 
+            // Field-Access-then-Transmute can just transmute the original value,
+            // so long as the bytes of a value from only from a single field.
+            if let Transmute = kind
+                && let Value::Projection(field_value, ProjectionElem::Field(field_idx, ())) =
+                    self.get(value)
+            {
+                if let Value::Projection(downcast_value, ProjectionElem::Downcast(_, _variant_idx)) =
+                    self.get(field_value)
+                    && let downcast_ty = self.ty(downcast_value)
+                    && let Ok(downcast_layout) = self.ecx.layout_of(downcast_ty)
+                    && let Ok(projected_layout) = self.ecx.layout_of(self.ty(value))
+                    && downcast_layout.size == projected_layout.size
+                {
+                    from = downcast_ty;
+                    value = downcast_value;
+                    was_updated_this_iteration = true;
+                    if projected_layout.ty == to {
+                        return Some(value);
+                    }
+                } else if let Some((f_idx, field_ty)) =
+                    self.value_is_all_in_one_field(self.ty(field_value), FIRST_VARIANT)
+                {
+                    assert_eq!(field_idx, f_idx, "{from} -> {field_ty}");
+                    from = self.ty(field_value);
+                    value = field_value;
+                    was_updated_this_iteration = true;
+                    if field_ty == to {
+                        return Some(value);
+                    }
+                }
+            }
+
             // Aggregate-then-Transmute can just transmute the original field value,
             // so long as the bytes of a value from only from a single field.
             if let Transmute = kind

library/core/src/ptr/non_null.rs

@@ -1,7 +1,7 @@
 use crate::clone::TrivialClone;
 use crate::cmp::Ordering;
 use crate::marker::{Destruct, PointeeSized, Unsize};
-use crate::mem::{MaybeUninit, SizedTypeProperties};
+use crate::mem::{MaybeUninit, SizedTypeProperties, transmute};
 use crate::num::NonZero;
 use crate::ops::{CoerceUnsized, DispatchFromDyn};
 use crate::pin::PinCoerceUnsized;
@@ -100,9 +100,8 @@ impl<T: Sized> NonNull<T> {
     #[must_use]
     #[inline]
     pub const fn without_provenance(addr: NonZero<usize>) -> Self {
-        let pointer = crate::ptr::without_provenance(addr.get());
-        // SAFETY: we know `addr` is non-zero.
-        unsafe { NonNull { pointer } }
+        // SAFETY: we know `addr` is non-zero and all nonzero integers are valid raw pointers.
+        unsafe { transmute(addr) }
     }
 
     /// Creates a new `NonNull` that is dangling, but well-aligned.
@@ -239,7 +238,7 @@ impl<T: PointeeSized> NonNull<T> {
                 "NonNull::new_unchecked requires that the pointer is non-null",
                 (ptr: *mut () = ptr as *mut ()) => !ptr.is_null()
             );
-            NonNull { pointer: ptr as _ }
+            transmute(ptr)
         }
     }
 
@@ -282,7 +281,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn from_ref(r: &T) -> Self {
         // SAFETY: A reference cannot be null.
-        unsafe { NonNull { pointer: r as *const T } }
+        unsafe { transmute(r as *const T) }
     }
 
     /// Converts a mutable reference to a `NonNull` pointer.
@@ -291,7 +290,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn from_mut(r: &mut T) -> Self {
         // SAFETY: A mutable reference cannot be null.
-        unsafe { NonNull { pointer: r as *mut T } }
+        unsafe { transmute(r as *mut T) }
     }
 
     /// Performs the same functionality as [`std::ptr::from_raw_parts`], except that a
@@ -502,7 +501,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn cast<U>(self) -> NonNull<U> {
         // SAFETY: `self` is a `NonNull` pointer which is necessarily non-null
-        unsafe { NonNull { pointer: self.as_ptr() as *mut U } }
+        unsafe { transmute(self.as_ptr() as *mut U) }
     }
 
     /// Try to cast to a pointer of another type by checking alignment.
@@ -581,7 +580,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: intrinsics::offset(self.as_ptr(), count) } }
+        unsafe { transmute(intrinsics::offset(self.as_ptr(), count)) }
     }
 
     /// Calculates the offset from a pointer in bytes.
@@ -605,7 +604,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_offset(count) } }
+        unsafe { transmute(self.as_ptr().byte_offset(count)) }
     }
 
     /// Adds an offset to a pointer (convenience for `.offset(count as isize)`).
@@ -657,7 +656,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: intrinsics::offset(self.as_ptr(), count) } }
+        unsafe { transmute(intrinsics::offset(self.as_ptr(), count)) }
     }
 
     /// Calculates the offset from a pointer in bytes (convenience for `.byte_offset(count as isize)`).
@@ -681,7 +680,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `add` guarantees that the resulting pointer is pointing
         // to an allocation, there can't be an allocation at null, thus it's safe to construct
         // `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_add(count) } }
+        unsafe { transmute(self.as_ptr().byte_add(count)) }
     }
 
     /// Subtracts an offset from a pointer (convenience for
@@ -763,7 +762,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `sub` guarantees that the resulting pointer is pointing
         // to an allocation, there can't be an allocation at null, thus it's safe to construct
         // `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_sub(count) } }
+        unsafe { transmute(self.as_ptr().byte_sub(count)) }
     }
 
     /// Calculates the distance between two pointers within the same allocation. The returned value is in

tests/codegen-llvm/loads.rs

@@ -58,7 +58,7 @@ pub fn load_raw_pointer<'a>(x: &*const i32) -> *const i32 {
 // CHECK-LABEL: @load_box
 #[no_mangle]
 pub fn load_box<'a>(x: Box<Box<i32>>) -> Box<i32> {
-    // CHECK: load ptr, ptr %{{.*}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META]], !noundef !{{[0-9]+}}
+    // CHECK: load ptr, ptr %{{.*}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !noundef !{{[0-9]+}}
     *x
 }
 

tests/codegen-units/item-collection/opaque-return-impls.rs

@@ -86,3 +86,4 @@ pub fn foo3() -> Box<dyn Iterator<Item = usize>> {
 //~ MONO_ITEM fn std::boxed::Box::<Counter>::new
 //~ MONO_ITEM fn Counter::new
 //~ MONO_ITEM fn std::fmt::Arguments::<'_>::from_str
+//~ MONO_ITEM fn std::boxed::box_new_uninit

tests/mir-opt/const_prop/transmute.option_field.GVN.32bit.diff

@@ -0,0 +1,42 @@
+- // MIR for `option_field` before GVN
++ // MIR for `option_field` after GVN
+  
+  fn option_field(_1: Option<NonNull<()>>) -> *const () {
+      debug x => _1;
+      let mut _0: *const ();
+      let mut _2: isize;
+      let mut _4: std::ptr::NonNull<()>;
+      scope 1 {
+          debug x => _3;
+          let _3: std::ptr::NonNull<()>;
+      }
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [1: bb1, otherwise: bb2];
+      }
+  
+      bb1: {
+-         StorageLive(_3);
++         nop;
+          _3 = copy ((_1 as Some).0: std::ptr::NonNull<()>);
+          StorageLive(_4);
+          _4 = copy _3;
+-         _0 = move _4 as *const () (Transmute);
++         _0 = copy _1 as *const () (Transmute);
+          StorageDead(_4);
+-         StorageDead(_3);
++         nop;
+          goto -> bb3;
+      }
+  
+      bb2: {
+          _0 = const 0_usize as *const () (PointerWithExposedProvenance);
+          goto -> bb3;
+      }
+  
+      bb3: {
+          return;
+      }
+  }
+  

tests/mir-opt/const_prop/transmute.option_field.GVN.64bit.diff

@@ -0,0 +1,42 @@
+- // MIR for `option_field` before GVN
++ // MIR for `option_field` after GVN
+  
+  fn option_field(_1: Option<NonNull<()>>) -> *const () {
+      debug x => _1;
+      let mut _0: *const ();
+      let mut _2: isize;
+      let mut _4: std::ptr::NonNull<()>;
+      scope 1 {
+          debug x => _3;
+          let _3: std::ptr::NonNull<()>;
+      }
+  
+      bb0: {
+          _2 = discriminant(_1);
+          switchInt(move _2) -> [1: bb1, otherwise: bb2];
+      }
+  
+      bb1: {
+-         StorageLive(_3);
++         nop;
+          _3 = copy ((_1 as Some).0: std::ptr::NonNull<()>);
+          StorageLive(_4);
+          _4 = copy _3;
+-         _0 = move _4 as *const () (Transmute);
++         _0 = copy _1 as *const () (Transmute);
+          StorageDead(_4);
+-         StorageDead(_3);
++         nop;
+          goto -> bb3;
+      }
+  
+      bb2: {
+          _0 = const 0_usize as *const () (PointerWithExposedProvenance);
+          goto -> bb3;
+      }
+  
+      bb3: {
+          return;
+      }
+  }
+  

tests/mir-opt/const_prop/transmute.rs

@@ -84,4 +84,12 @@ pub unsafe fn unreachable_box() -> ! {
     match *x {}
 }
 
+// EMIT_MIR transmute.option_field.GVN.diff
+pub unsafe fn option_field(x: Option<std::ptr::NonNull<()>>) -> *const () {
+    // CHECK-LABEL: fn option_field(
+    // CHECK: _3 = copy ((_1 as Some).0: std::ptr::NonNull<()>)
+    // CHECK: _0 = copy _1 as *const () (Transmute)
+    if let Some(x) = x { unsafe { transmute(x) } } else { 0 as *const () }
+}
+
 enum Never {}

tests/mir-opt/const_prop/transmute.unreachable_box.GVN.32bit.diff

@@ -14,7 +14,7 @@
 -         _1 = const 1_usize as std::boxed::Box<Never> (Transmute);
 -         _2 = copy ((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>) as *const Never (Transmute);
 +         _1 = const Box::<Never>(std::ptr::Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global);
-+         _2 = const std::ptr::NonNull::<Never> {{ pointer: {0x1 as *const Never} }} as *const Never (Transmute);
++         _2 = const std::boxed::Box::<Never>(std::ptr::Unique::<Never> {{ pointer: std::ptr::NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: std::marker::PhantomData::<Never> }}, std::alloc::Global) as *const Never (Transmute);
           unreachable;
       }
   }

tests/mir-opt/const_prop/transmute.unreachable_box.GVN.64bit.diff

@@ -14,7 +14,7 @@
 -         _1 = const 1_usize as std::boxed::Box<Never> (Transmute);
 -         _2 = copy ((_1.0: std::ptr::Unique<Never>).0: std::ptr::NonNull<Never>) as *const Never (Transmute);
 +         _1 = const Box::<Never>(std::ptr::Unique::<Never> {{ pointer: NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: PhantomData::<Never> }}, std::alloc::Global);
-+         _2 = const std::ptr::NonNull::<Never> {{ pointer: {0x1 as *const Never} }} as *const Never (Transmute);
++         _2 = const std::boxed::Box::<Never>(std::ptr::Unique::<Never> {{ pointer: std::ptr::NonNull::<Never> {{ pointer: {0x1 as *const Never} }}, _marker: std::marker::PhantomData::<Never> }}, std::alloc::Global) as *const Never (Transmute);
           unreachable;
       }
   }

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.DataflowConstProp.32bit.panic-abort.diff

@@ -20,15 +20,6 @@
                       scope 8 (inlined std::ptr::Alignment::as_nonzero) {
                       }
                       scope 9 (inlined NonNull::<[bool; 0]>::without_provenance) {
-                          let _6: *const [bool; 0];
-                          scope 10 {
-                          }
-                          scope 11 (inlined NonZero::<usize>::get) {
-                          }
-                          scope 12 (inlined std::ptr::without_provenance::<[bool; 0]>) {
-                              scope 13 (inlined without_provenance_mut::<[bool; 0]>) {
-                              }
-                          }
                       }
                   }
                   scope 7 (inlined std::ptr::Alignment::of::<[bool; 0]>) {
@@ -43,10 +34,7 @@
           StorageLive(_3);
           StorageLive(_4);
           StorageLive(_5);
-          StorageLive(_6);
-          _6 = const {0x1 as *const [bool; 0]};
           _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};
-          StorageDead(_6);
           _4 = const std::ptr::Unique::<[bool; 0]> {{ pointer: NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }}, _marker: PhantomData::<[bool; 0]> }};
           StorageDead(_5);
           _3 = const std::ptr::Unique::<[bool]> {{ pointer: NonNull::<[bool]> {{ pointer: Indirect { alloc_id: ALLOC0, offset: Size(0 bytes) }: *const [bool] }}, _marker: PhantomData::<[bool]> }};