refactor PointeeInfo

Make `size`/`align` always correct rather than conditionally on the
`safe` field. This makes it less error prone and easier to work with for
`MaybeDangling` / potential future pointer kinds like `Aligned<_>`.

Author: WaffleLapkin

compiler/rustc_abi/src/lib.rs

@@ -2145,22 +2145,22 @@ pub enum PointerKind {
 }
 
 /// Encodes extra information we have about a pointer.
+///
 /// Note that this information is advisory only, and backends are free to ignore it:
 /// if the information is wrong, that can cause UB, but if the information is absent,
 /// 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.
     pub safe: Option<PointerKind>,
-    /// If `safe` is `Some`, then the pointer is either null or dereferenceable for this many bytes.
+    /// If `size` is not zero, 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_cranelift/src/base.rs

@@ -10,7 +10,7 @@ use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_index::IndexVec;
 use rustc_middle::ty::TypeVisitableExt;
 use rustc_middle::ty::adjustment::PointerCoercion;
-use rustc_middle::ty::layout::FnAbiOf;
+use rustc_middle::ty::layout::{FnAbiOf, HasTypingEnv as _};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::config::OutputFilenames;
 use rustc_span::Symbol;
@@ -924,19 +924,26 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                 count,
             }) => {
                 let dst = codegen_operand(fx, dst);
-                let pointee = dst
-                    .layout()
-                    .pointee_info_at(fx, rustc_abi::Size::ZERO)
-                    .expect("Expected pointer");
+
+                let &ty::RawPtr(pointee, _) = dst.layout().ty.kind() else {
+                    bug!("expected pointer")
+                };
+                let pointee_layout = fx
+                    .tcx
+                    .layout_of(fx.typing_env().as_query_input(pointee))
+                    .expect("expected pointee to have a layout");
+                let elem_size: u64 = pointee_layout.layout.size().bytes();
+
                 let dst = dst.load_scalar(fx);
                 let src = codegen_operand(fx, src).load_scalar(fx);
                 let count = codegen_operand(fx, count).load_scalar(fx);
-                let elem_size: u64 = pointee.size.bytes();
+
                 let bytes = if elem_size != 1 {
                     fx.bcx.ins().imul_imm(count, elem_size as i64)
                 } else {
                     count
                 };
+
                 fx.bcx.call_memcpy(fx.target_config, dst, src, bytes);
             }
         },

compiler/rustc_codegen_gcc/src/type_of.rs

@@ -288,8 +288,10 @@ 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,15 +77,22 @@ 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 elem_size = pointee_layout.layout.size().bytes();
+                let bytes =
+                    if elem_size != 1 { bx.mul(count, bx.const_usize(elem_size)) } else { count };
+
+                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);
             }
             mir::StatementKind::FakeRead(..)

compiler/rustc_middle/src/ty/layout.rs

@@ -1023,40 +1023,66 @@ 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::RawPtr(_, _) | ty::FnPtr(..) if offset.bytes() == 0 => {
+                Some(PointeeInfo { safe: None, size: Size::ZERO, align: 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::Ref(_, ty, mt) if offset.bytes() == 0 => {
+                tcx.layout_of(typing_env.as_query_input(ty)).ok().map(|layout| {
+                    // Use conservative pointer kind if not optimizing. This saves us the
+                    // Freeze/Unpin queries, and can save time in the codegen backend (noalias
+                    // attributes in LLVM have compile-time cost even in unoptimized builds).
+                    let optimize = tcx.sess.opts.optimize != OptLevel::No;
+
+                    let size;
+                    let kind = match mt {
+                        hir::Mutability::Not => {
+                            let frozen = optimize && ty.is_freeze(tcx, typing_env);
+
+                            // Non-frozen shared references are not necessarily dereferenceable for the entire duration of the function
+                            // (see <https://github.com/rust-lang/rust/pull/98017>)
+                            // (if we had "dereferenceable on entry", we could support this)
+                            size = if frozen { layout.size } else { Size::ZERO };
+
+                            PointerKind::SharedRef { frozen }
+                        }
+                        hir::Mutability::Mut => {
+                            let unpin = optimize
+                                && ty.is_unpin(tcx, typing_env)
+                                && ty.is_unsafe_unpin(tcx, typing_env);
+
+                            // Mutable references to potentially self-referential types are not
+                            // necessarily dereferenceable for the entire duration of the function
+                            // (see <https://github.com/rust-lang/unsafe-code-guidelines/issues/381>)
+                            // (if we had "dereferenceable on entry", we could support this)
+                            size = if unpin { layout.size } else { Size::ZERO };
+
+                            PointerKind::MutableRef { unpin }
+                        }
+                    };
+                    PointeeInfo { safe: Some(kind), size, align: Some(layout.align.abi) }
                 })
             }
-            ty::Ref(_, ty, mt) if offset.bytes() == 0 => {
-                // Use conservative pointer kind if not optimizing. This saves us the
-                // Freeze/Unpin queries, and can save time in the codegen backend (noalias
-                // attributes in LLVM have compile-time cost even in unoptimized builds).
+
+            ty::Adt(..)
+                if offset.bytes() == 0
+                    && let Some(pointee) = this.ty.boxed_ty() =>
+            {
                 let optimize = tcx.sess.opts.optimize != OptLevel::No;
-                let kind = match mt {
-                    hir::Mutability::Not => {
-                        PointerKind::SharedRef { frozen: optimize && ty.is_freeze(tcx, typing_env) }
-                    }
-                    hir::Mutability::Mut => PointerKind::MutableRef {
+
+                tcx.layout_of(typing_env.as_query_input(pointee)).ok().map(|layout| PointeeInfo {
+                    safe: Some(PointerKind::Box {
                         unpin: optimize
-                            && ty.is_unpin(tcx, typing_env)
-                            && ty.is_unsafe_unpin(tcx, typing_env),
-                    },
-                };
+                            && pointee.is_unpin(tcx, typing_env)
+                            && pointee.is_unsafe_unpin(tcx, typing_env),
+                        global: this.ty.is_box_global(tcx),
+                    }),
 
-                tcx.layout_of(typing_env.as_query_input(ty)).ok().map(|layout| PointeeInfo {
-                    size: layout.size,
-                    align: layout.align.abi,
-                    safe: Some(kind),
+                    // `Box` are not necessarily dereferenceable for the entire duration of the function as
+                    // they can be deallocated at any time.
+                    // (if we had "dereferenceable on entry", we could support this)
+                    size: Size::ZERO,
+
+                    align: Some(layout.align.abi),
                 })
             }
 
@@ -1098,7 +1124,7 @@ where
                         }
                     }
                     Variants::Multiple { .. } => None,
-                    _ => Some(this),
+                    Variants::Empty | Variants::Single { .. } => Some(this),
                 };
 
                 if let Some(variant) = data_variant
@@ -1135,24 +1161,6 @@ where
                     }
                 }
 
-                // Fixup info for the first field of a `Box`. Recursive traversal will have found
-                // the raw pointer, so size and align are set to the boxed type, but `pointee.safe`
-                // will still be `None`.
-                if let Some(ref mut pointee) = result {
-                    if offset.bytes() == 0
-                        && let Some(boxed_ty) = this.ty.boxed_ty()
-                    {
-                        debug_assert!(pointee.safe.is_none());
-                        let optimize = tcx.sess.opts.optimize != OptLevel::No;
-                        pointee.safe = Some(PointerKind::Box {
-                            unpin: optimize
-                                && boxed_ty.is_unpin(tcx, typing_env)
-                                && boxed_ty.is_unsafe_unpin(tcx, typing_env),
-                            global: this.ty.is_box_global(tcx),
-                        });
-                    }
-                }
-
                 result
             }
         };

compiler/rustc_ty_utils/src/abi.rs

@@ -302,42 +302,31 @@ fn arg_attrs_for_rust_scalar<'tcx>(
 
     let tcx = cx.tcx();
 
-    if let Some(pointee) = layout.pointee_info_at(&cx, offset) {
-        let kind = if let Some(kind) = pointee.safe {
-            Some(kind)
-        } else if let Some(pointee) = drop_target_pointee {
-            assert_eq!(pointee, layout.ty.builtin_deref(true).unwrap());
-            assert_eq!(offset, Size::ZERO);
-            // The argument to `drop_in_place` is semantically equivalent to a mutable reference.
-            let mutref = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, pointee);
-            let layout = cx.layout_of(mutref).unwrap();
-            layout.pointee_info_at(&cx, offset).and_then(|pi| pi.safe)
-        } else {
-            None
+    let drop_target_pointee_info = drop_target_pointee.and_then(|pointee| {
+        assert_eq!(pointee, layout.ty.builtin_deref(true).unwrap());
+        assert_eq!(offset, Size::ZERO);
+        // The argument to `drop_in_place` is semantically equivalent to a mutable reference.
+        let mutref = Ty::new_mut_ref(tcx, tcx.lifetimes.re_erased, pointee);
+        let layout = cx.layout_of(mutref).unwrap();
+        layout.pointee_info_at(&cx, offset)
+    });
+
+    if let Some(pointee) = drop_target_pointee_info.or_else(|| layout.pointee_info_at(&cx, offset))
+    {
+        if let Some(align) = pointee.align {
+            attrs.pointee_align = Some(align.min(cx.tcx().sess.target.max_reliable_alignment()));
+        }
+
+        // LLVM dereferenceable attribute has unclear semantics on the return type,
+        // they seem to be "dereferenceable until the end of the program", which is
+        // generally, not valid for references. See
+        // <https://rust-lang.zulipchat.com/#narrow/channel/136281-t-opsem/topic/LLVM.20dereferenceable.20on.20return.20type/with/563001493>
+        attrs.pointee_size = match is_return {
+            false => pointee.size,
+            true => Size::ZERO,
         };
-        if let Some(kind) = kind {
-            attrs.pointee_align =
-                Some(pointee.align.min(cx.tcx().sess.target.max_reliable_alignment()));
-
-            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
-                // generally, not valid for references. See
-                // <https://rust-lang.zulipchat.com/#narrow/channel/136281-t-opsem/topic/LLVM.20dereferenceable.20on.20return.20type/with/563001493>
-                _ if is_return => Size::ZERO,
-                // `Box` are not necessarily dereferenceable for the entire duration of the function as
-                // they can be deallocated at any time. Same for non-frozen shared references (see
-                // <https://github.com/rust-lang/rust/pull/98017>), and for mutable references to
-                // potentially self-referential types (see
-                // <https://github.com/rust-lang/unsafe-code-guidelines/issues/381>). If LLVM had a way
-                // to say "dereferenceable on entry" we could use it here.
-                PointerKind::Box { .. }
-                | PointerKind::SharedRef { frozen: false }
-                | PointerKind::MutableRef { unpin: false } => Size::ZERO,
-                PointerKind::SharedRef { frozen: true }
-                | PointerKind::MutableRef { unpin: true } => pointee.size,
-            };
 
+        if let Some(kind) = pointee.safe {
             // The aliasing rules for `Box<T>` are still not decided, but currently we emit
             // `noalias` for it. This can be turned off using an unstable flag.
             // See https://github.com/rust-lang/unsafe-code-guidelines/issues/326
@@ -554,7 +543,14 @@ fn fn_abi_new_uncached<'tcx>(
         };
 
         Ok(ArgAbi::new(cx, layout, |scalar, offset| {
-            arg_attrs_for_rust_scalar(*cx, scalar, layout, offset, is_return, drop_target_pointee)
+            arg_attrs_for_rust_scalar(
+                *cx,
+                scalar,
+                layout,
+                offset,
+                is_return,
+                drop_target_pointee.filter(|_| offset == Size::ZERO),
+            )
         }))
     };