add semantics to MaybeDangling

Author: WaffleLapkin

compiler/rustc_abi/src/lib.rs

@@ -2153,6 +2153,8 @@ pub enum PointerKind {
 pub struct PointeeInfo {
     /// If this is `None`, then this is a raw pointer.
     pub safe: Option<PointerKind>,
+    /// If this is true, the pointer is wrapped in `MaybeDangling`.
+    pub may_dangle: bool,
     /// 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

compiler/rustc_middle/src/ty/layout.rs

@@ -1023,9 +1023,12 @@ where
         let typing_env = cx.typing_env();
 
         let pointee_info = match *this.ty.kind() {
-            ty::RawPtr(_, _) | ty::FnPtr(..) if offset.bytes() == 0 => {
-                Some(PointeeInfo { safe: None, size: Size::ZERO, align: Align::ONE })
-            }
+            ty::RawPtr(_, _) | ty::FnPtr(..) if offset.bytes() == 0 => Some(PointeeInfo {
+                safe: None,
+                size: Size::ZERO,
+                align: Align::ONE,
+                may_dangle: false,
+            }),
             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
@@ -1059,7 +1062,12 @@ where
                             PointerKind::MutableRef { unpin }
                         }
                     };
-                    PointeeInfo { safe: Some(kind), size, align: layout.align.abi }
+                    PointeeInfo {
+                        safe: Some(kind),
+                        size,
+                        align: layout.align.abi,
+                        may_dangle: false,
+                    }
                 })
             }
 
@@ -1083,6 +1091,20 @@ where
                     size: Size::ZERO,
 
                     align: layout.align.abi,
+                    may_dangle: false,
+                })
+            }
+
+            ty::Adt(adt_def, ..) if adt_def.is_maybe_dangling() => {
+                Self::ty_and_layout_pointee_info_at(this.field(cx, 0), cx, offset).map(|info| {
+                    PointeeInfo {
+                        // Mark the pointer as possibly dangling
+                        // (thus removing noalias in case of llvm backend)
+                        may_dangle: true,
+                        // Make sure we don't assert dereferenceability of the pointer.
+                        size: Size::ZERO,
+                        ..info
+                    }
                 })
             }
 

compiler/rustc_ty_utils/src/abi.rs

@@ -344,11 +344,12 @@ fn arg_attrs_for_rust_scalar<'tcx>(
             // not return values.
             //
             // `&mut T` and `Box<T>` where `T: Unpin` are unique and hence `noalias`.
-            let no_alias = match kind {
-                PointerKind::SharedRef { frozen } => frozen,
-                PointerKind::MutableRef { unpin } => unpin && noalias_mut_ref,
-                PointerKind::Box { unpin, global } => unpin && global && noalias_for_box,
-            };
+            let no_alias = !pointee.may_dangle
+                && match kind {
+                    PointerKind::SharedRef { frozen } => frozen,
+                    PointerKind::MutableRef { unpin } => unpin && noalias_mut_ref,
+                    PointerKind::Box { unpin, global } => unpin && global && noalias_for_box,
+                };
             // We can never add `noalias` in return position; that LLVM attribute has some very surprising semantics
             // (see <https://github.com/rust-lang/unsafe-code-guidelines/issues/385#issuecomment-1368055745>).
             if no_alias && !is_return {

library/core/src/mem/maybe_dangling.rs

@@ -4,10 +4,6 @@ use crate::{mem, ptr};
 
 /// Allows wrapped [references] and [boxes] to dangle.
 ///
-/// <section class="warning">
-/// This type is not properly implemented yet, and the documentation below is thus not accurate.
-/// </section>
-///
 /// That is, if a reference (or a `Box`) is wrapped in `MaybeDangling` (including when in a
 /// (nested) field of a compound type wrapped in `MaybeDangling`), it does not have to follow
 /// pointer aliasing rules or be dereferenceable.

tests/codegen-llvm/manually_drop_refs.rs

@@ -6,37 +6,58 @@
 
 use std::mem::ManuallyDrop;
 
-// CHECK: define {{(dso_local )?}}noundef nonnull ptr @f(ptr noalias noundef nonnull readnone returned {{(captures\(ret: address, provenance\))?}} %x) unnamed_addr
+// CHECK: define {{(dso_local )?}}noundef nonnull ptr @f
+// CHECK-NOT: noalias
+// CHECK-NOT: dereferenceable
+// CHECK-SAME: unnamed_addr
 #[no_mangle]
 pub fn f(x: ManuallyDrop<Box<u8>>) -> ManuallyDrop<Box<u8>> {
     x
 }
 
-// CHECK: define {{(dso_local )?}}noundef nonnull ptr @g(ptr noalias noundef readonly returned {{(captures\(ret: address, read_provenance\))?}} dereferenceable(1) %x) unnamed_addr
+// CHECK: define {{(dso_local )?}}noundef nonnull ptr @g
+// CHECK-NOT: noalias
+// CHECK-NOT: dereferenceable
+// CHECK-SAME: unnamed_addr
 #[no_mangle]
 pub fn g(x: ManuallyDrop<&u8>) -> ManuallyDrop<&u8> {
     x
 }
 
-// CHECK: define {{(dso_local )?}}noundef nonnull ptr @h(ptr noalias noundef readnone returned {{(captures\(ret: address, provenance\))?}} dereferenceable(1) %x) unnamed_addr
+// CHECK: define {{(dso_local )?}}noundef nonnull ptr @h
+// CHECK-NOT: noalias
+// CHECK-NOT: dereferenceable
+// CHECK-SAME: unnamed_addr
 #[no_mangle]
 pub fn h(x: ManuallyDrop<&mut u8>) -> ManuallyDrop<&mut u8> {
     x
 }
 
-// CHECK: define {{(dso_local )?}}noundef nonnull align 4 ptr @i(ptr noalias noundef nonnull readnone returned align 4 {{(captures\(ret: address, provenance\))?}} %x) unnamed_addr
+// CHECK: define {{(dso_local )?}}noundef nonnull align 4 ptr @i
+// CHECK-NOT: noalias
+// CHECK-NOT: dereferenceable
+// CHECK-SAME: align 4
+// CHECK-SAME: unnamed_addr
 #[no_mangle]
 pub fn i(x: ManuallyDrop<Box<u32>>) -> ManuallyDrop<Box<u32>> {
     x
 }
 
-// CHECK: define {{(dso_local )?}}noundef nonnull align 4 ptr @j(ptr noalias noundef readonly returned align 4 {{(captures\(ret: address, read_provenance\))?}} dereferenceable(4) %x) unnamed_addr
+// CHECK: define {{(dso_local )?}}noundef nonnull align 4 ptr @j
+// CHECK-NOT: noalias
+// CHECK-NOT: dereferenceable
+// CHECK-SAME: align 4
+// CHECK-SAME: unnamed_addr
 #[no_mangle]
 pub fn j(x: ManuallyDrop<&u32>) -> ManuallyDrop<&u32> {
     x
 }
 
-// CHECK: define {{(dso_local )?}}noundef nonnull align 4 ptr @k(ptr noalias noundef readnone returned align 4 {{(captures\(ret: address, provenance\))?}} dereferenceable(4) %x) unnamed_addr
+// CHECK: define {{(dso_local )?}}noundef nonnull align 4 ptr @k
+// CHECK-NOT: noalias
+// CHECK-NOT: dereferenceable
+// CHECK-SAME: align 4
+// CHECK-SAME: unnamed_addr
 #[no_mangle]
 pub fn k(x: ManuallyDrop<&mut u32>) -> ManuallyDrop<&mut u32> {
     x

tests/codegen-llvm/vtable-upcast.rs

@@ -56,7 +56,7 @@ pub fn upcast_diamond_to_a(x: &dyn Diamond) -> &dyn A {
 }
 
 // CHECK-LABEL: upcast_diamond_to_b
-// CHECK-SAME: (ptr [[DATA_PTR:%.+]], ptr align 8 [[VTABLE_PTR:%.+]])
+// CHECK-SAME: (ptr [[DATA_PTR:%.+]], ptr align {{[0-9]+}} [[VTABLE_PTR:%.+]])
 #[no_mangle]
 pub fn upcast_diamond_to_b(x: &dyn Diamond) -> &dyn B {
     // Requires adjustment, since it's a non-first supertrait.