preserve alignment information for MaybeDangling wrapped references

Author: WaffleLapkin

compiler/rustc_abi/src/lib.rs

@@ -2137,17 +2137,17 @@ pub enum PointerKind {
 /// that must always be okay.
 #[derive(Copy, Clone, Debug)]
 pub struct PointeeInfo {
-    /// If this is `None`, then this is a raw pointer, so size and alignment are not guaranteed to
-    /// be reliable.
+    /// If this is `None`, then this is a raw pointer, so size is not guaranteed to be reliable.
+    /// Note that the alignment might still be accurate, if provided.
     pub safe: Option<PointerKind>,
     /// If `safe` is `Some`, then the pointer is either null or dereferenceable for this many bytes.
     /// On a function argument, "dereferenceable" here means "dereferenceable for the entire duration
     /// of this function call", i.e. it is UB for the memory that this pointer points to be freed
     /// while this function is still running.
     /// The size can be zero if the pointer is not dereferenceable.
     pub size: Size,
-    /// If `safe` is `Some`, then the pointer is aligned as indicated.
-    pub align: Align,
+    /// If `Some`, then the pointer is aligned as indicated.
+    pub align: Option<Align>,
 }
 
 impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {

compiler/rustc_codegen_gcc/src/type_of.rs

@@ -288,8 +288,9 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
             Float(f) => cx.type_from_float(f),
             Pointer(address_space) => {
                 // If we know the alignment, pick something better than i8.
-                let pointee = if let Some(pointee) = self.pointee_info_at(cx, offset) {
-                    cx.type_pointee_for_align(pointee.align)
+                let pointee = if let Some(pointee) = self.pointee_info_at(cx, offset)
+                    && let Some(align) = pointee.align {
+                    cx.type_pointee_for_align(align)
                 } else {
                     cx.type_i8()
                 };

compiler/rustc_codegen_llvm/src/builder.rs

@@ -714,9 +714,9 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                     }
 
                     if let Some(pointee) = layout.pointee_info_at(bx, offset)
-                        && let Some(_) = pointee.safe
+                        && let Some(align) = pointee.align
                     {
-                        bx.align_metadata(load, pointee.align);
+                        bx.align_metadata(load, align);
                     }
                 }
                 abi::Primitive::Float(_) => {}

compiler/rustc_codegen_ssa/src/mir/statement.rs

@@ -1,5 +1,5 @@
 use rustc_middle::mir::{self, NonDivergingIntrinsic, StmtDebugInfo};
-use rustc_middle::span_bug;
+use rustc_middle::{bug, span_bug, ty};
 use tracing::instrument;
 
 use super::{FunctionCx, LocalRef};
@@ -77,13 +77,18 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let dst_val = self.codegen_operand(bx, dst);
                 let src_val = self.codegen_operand(bx, src);
                 let count = self.codegen_operand(bx, count).immediate();
-                let pointee_layout = dst_val
-                    .layout
-                    .pointee_info_at(bx, rustc_abi::Size::ZERO)
-                    .expect("Expected pointer");
-                let bytes = bx.mul(count, bx.const_usize(pointee_layout.size.bytes()));
 
-                let align = pointee_layout.align;
+                let &ty::RawPtr(pointee, _) = dst_val.layout.ty.kind() else {
+                    bug!("expected pointer")
+                };
+                let pointee_layout = bx
+                    .tcx()
+                    .layout_of(bx.typing_env().as_query_input(pointee))
+                    .expect("expected pointee to have a layout");
+
+                let bytes = bx.mul(count, bx.const_usize(pointee_layout.layout.size().bytes()));
+
+                let align = pointee_layout.layout.align.abi;
                 let dst = dst_val.immediate();
                 let src = src_val.immediate();
                 bx.memcpy(dst, align, src, align, bytes, crate::MemFlags::empty(), None);

compiler/rustc_middle/src/ty/layout.rs

@@ -1023,19 +1023,8 @@ where
         let typing_env = cx.typing_env();
 
         let pointee_info = match *this.ty.kind() {
-            ty::RawPtr(p_ty, _) if offset.bytes() == 0 => {
-                tcx.layout_of(typing_env.as_query_input(p_ty)).ok().map(|layout| PointeeInfo {
-                    size: layout.size,
-                    align: layout.align.abi,
-                    safe: None,
-                })
-            }
-            ty::FnPtr(..) if offset.bytes() == 0 => {
-                tcx.layout_of(typing_env.as_query_input(this.ty)).ok().map(|layout| PointeeInfo {
-                    size: layout.size,
-                    align: layout.align.abi,
-                    safe: None,
-                })
+            ty::RawPtr(_, _) | ty::FnPtr(..) if offset.bytes() == 0 => {
+                Some(PointeeInfo { size: Size::ZERO, align: None, safe: None })
             }
             ty::Ref(_, ty, mt) if offset.bytes() == 0 => {
                 // Use conservative pointer kind if not optimizing. This saves us the
@@ -1055,15 +1044,23 @@ where
 
                 tcx.layout_of(typing_env.as_query_input(ty)).ok().map(|layout| PointeeInfo {
                     size: layout.size,
-                    align: layout.align.abi,
+                    align: Some(layout.align.abi),
                     safe: Some(kind),
                 })
             }
 
             ty::Adt(adt_def, ..) if adt_def.is_maybe_dangling() => {
-                // FIXME: what is the exact effect of maybe dangling?
-                Self::ty_and_layout_pointee_info_at(this.field(cx, 0), cx, offset)
-                    .map(|info| PointeeInfo { safe: None, ..info })
+                Self::ty_and_layout_pointee_info_at(this.field(cx, 0), cx, offset).map(|info| {
+                    PointeeInfo {
+                        // Downgrade references to pointers (in llvm this strips noalias)
+                        safe: None,
+                        // Make sure we don't assert dereferenceability of the pointer.
+                        // That is also implied by `safe: None`, but set this explicitly to be sure.
+                        size: Size::ZERO,
+                        // Keep the alignment info
+                        align: info.align,
+                    }
+                })
             }
 
             _ => {

compiler/rustc_ty_utils/src/abi.rs

@@ -315,10 +315,12 @@ fn arg_attrs_for_rust_scalar<'tcx>(
         } else {
             None
         };
-        if let Some(kind) = kind {
-            attrs.pointee_align =
-                Some(pointee.align.min(cx.tcx().sess.target.max_reliable_alignment()));
 
+        if let Some(align) = pointee.align {
+            attrs.pointee_align = Some(align.min(cx.tcx().sess.target.max_reliable_alignment()));
+        }
+
+        if let Some(kind) = kind {
             attrs.pointee_size = match kind {
                 // LLVM dereferenceable attribute has unclear semantics on the return type,
                 // they seem to be "dereferenceable until the end of the program", which is

tests/codegen-llvm/manually_drop_refs.rs

@@ -15,7 +15,7 @@ pub fn f(x: ManuallyDrop<Box<u8>>) -> ManuallyDrop<Box<u8>> {
     x
 }
 
-// CHECK: define noundef nonnull ptr @g
+// CHECK: define noundef nonnull align 1 ptr @g
 // CHECK-NOT: noalias
 // CHECK-NOT: dereferenceable
 // CHECK-SAME: unnamed_addr
@@ -24,7 +24,7 @@ pub fn g(x: ManuallyDrop<&u8>) -> ManuallyDrop<&u8> {
     x
 }
 
-// CHECK: define noundef nonnull ptr @h
+// CHECK: define noundef nonnull align 1 ptr @h
 // CHECK-NOT: noalias
 // CHECK-NOT: dereferenceable
 // CHECK-SAME: unnamed_addr