change type argument of drop_in_place lang item to &mut _

Author: WaffleLapkin

compiler/rustc_codegen_cranelift/example/mini_core.rs

@@ -555,6 +555,7 @@ unsafe extern "C" {
 pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
     // Code here does not matter - this is replaced by the
     // real drop glue by the compiler.
+    // FIXME
     unsafe {
         drop_in_place(to_drop);
     }

compiler/rustc_const_eval/src/interpret/call.rs

@@ -901,7 +901,8 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         };
         let fn_abi = self.fn_abi_of_instance_no_deduced_attrs(instance, ty::List::empty())?;
 
-        let arg = self.mplace_to_ptr(&place)?;
+        let arg = self.mplace_to_mut_ref(&place)?;
+
         let ret = MPlaceTy::fake_alloc_zst(self.layout_of(self.tcx.types.unit)?);
 
         self.init_fn_call(

compiler/rustc_mir_transform/src/coroutine/drop.rs

@@ -596,10 +596,6 @@ pub(super) fn create_coroutine_drop_shim<'tcx>(
 
     make_coroutine_state_argument_indirect(tcx, &mut body);
 
-    // Change the coroutine argument from &mut to *mut
-    body.local_decls[SELF_ARG] =
-        LocalDecl::with_source_info(Ty::new_mut_ptr(tcx, coroutine_ty), source_info);
-
     // Make sure we remove dead blocks to remove
     // unrelated code from the resume part of the function
     simplify::remove_dead_blocks(&mut body);

compiler/rustc_ty_utils/src/abi.rs

@@ -340,21 +340,12 @@ fn fn_abi_of_instance_raw<'tcx>(
 }
 
 /// Returns argument attributes for a scalar argument.
-///
-/// `drop_target_pointee`, if set, causes pointer-typed scalars to be treated like mutable
-/// references to the given type. This is used to special-case the argument of `ptr::drop_in_place`,
-/// interpreting it as `&mut T` instead of `*mut T`, for the purposes of attributes (which is valid
-/// as per its safety contract). If `drop_target_pointee` is set, `offset` must be 0 and `layout.ty`
-/// must be a pointer to the given type. Note that for wide pointers this function is called twice
-/// -- once for the data pointer and once for the vtable pointer. `drop_target_pointee` must only
-/// be set for the data pointer.
 fn arg_attrs_for_rust_scalar<'tcx>(
     cx: LayoutCx<'tcx>,
     scalar: Scalar,
     layout: TyAndLayout<'tcx>,
     offset: Size,
     is_return: bool,
-    drop_target_pointee: Option<Ty<'tcx>>,
 ) -> ArgAttributes {
     let mut attrs = ArgAttributes::new();
 
@@ -374,23 +365,13 @@ fn arg_attrs_for_rust_scalar<'tcx>(
 
     // Set `nonnull` if the validity range excludes zero, or for the argument to `drop_in_place`,
     // which must be nonnull per its documented safety requirements.
-    if !valid_range.contains(0) || drop_target_pointee.is_some() {
+    if !valid_range.contains(0) {
         attrs.set(ArgAttribute::NonNull);
     }
 
     let tcx = cx.tcx();
 
-    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(pointee) = layout.pointee_info_at(&cx, offset) {
         if pointee.align > Align::ONE {
             attrs.pointee_align =
                 Some(pointee.align.min(cx.tcx().sess.target.max_reliable_alignment()));
@@ -589,20 +570,10 @@ fn fn_abi_new_uncached<'tcx>(
         extra_args
     };
 
-    let is_drop_in_place = determined_fn_def_id.is_some_and(|def_id| {
-        tcx.is_lang_item(def_id, LangItem::DropInPlace)
-            || tcx.is_lang_item(def_id, LangItem::AsyncDropInPlace)
-    });
-
     let arg_of = |ty: Ty<'tcx>, arg_idx: Option<usize>| -> Result<_, &'tcx FnAbiError<'tcx>> {
         let span = tracing::debug_span!("arg_of");
         let _entered = span.enter();
         let is_return = arg_idx.is_none();
-        let is_drop_target = is_drop_in_place && arg_idx == Some(0);
-        let drop_target_pointee = is_drop_target.then(|| match ty.kind() {
-            ty::RawPtr(ty, _) => *ty,
-            _ => bug!("argument to drop_in_place is not a raw ptr: {:?}", ty),
-        });
 
         let layout = cx.layout_of(ty).map_err(|err| &*tcx.arena.alloc(FnAbiError::Layout(*err)))?;
         let layout = if is_virtual_call && arg_idx == Some(0) {
@@ -615,16 +586,7 @@ fn fn_abi_new_uncached<'tcx>(
         };
 
         Ok(ArgAbi::new(cx, layout, |scalar, offset| {
-            arg_attrs_for_rust_scalar(
-                *cx,
-                scalar,
-                layout,
-                offset,
-                is_return,
-                // Only set `drop_target_pointee` for the data part of a wide pointer.
-                // See `arg_attrs_for_rust_scalar` docs for more information.
-                drop_target_pointee.filter(|_| offset == Size::ZERO),
-            )
+            arg_attrs_for_rust_scalar(*cx, scalar, layout, offset, is_return)
         }))
     };
 

library/core/src/future/async_drop.rs

@@ -52,6 +52,7 @@ pub trait AsyncDrop {
 /// [ptr::drop_in_place]: crate::ptr::drop_in_place()
 #[unstable(feature = "async_drop", issue = "126482")]
 #[lang = "async_drop_in_place"]
+// FIXME: accept a reference here instead
 pub async unsafe fn async_drop_in_place<T: ?Sized>(_to_drop: *mut T) {
     // Code here does not matter - this is replaced by the
     // real implementation by the compiler.

library/core/src/ptr/mod.rs

@@ -801,20 +801,35 @@ pub const unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize) {
 /// // Ensure that the last item was dropped.
 /// assert!(weak.upgrade().is_none());
 /// ```
+#[inline(always)]
 #[stable(feature = "drop_in_place", since = "1.8.0")]
-#[lang = "drop_in_place"]
-#[allow(unconditional_recursion)]
 #[rustc_diagnostic_item = "ptr_drop_in_place"]
 #[rustc_const_unstable(feature = "const_drop_in_place", issue = "109342")]
 pub const unsafe fn drop_in_place<T: PointeeSized>(to_drop: *mut T)
 where
     T: [const] Destruct,
 {
-    // Code here does not matter - this is replaced by the
-    // real drop glue by the compiler.
+    // Due to historic reasons, `drop_in_place` takes a pointer rather than a reference,
+    // which results in worse codegen since we don't apply noalias/dereferenceable llvm
+    // attributes to pointer arguments. To workaround this without breaking public
+    // interface, `drop_in_place` calls the lang item, rather than being one directly.
+
+    #[lang = "drop_in_place"]
+    const unsafe fn drop_in_place_glue<T: PointeeSized>(_: &mut T)
+    where
+        T: [const] Destruct,
+    {
+        // Code here does not matter - this is replaced by the
+        // real drop glue by the compiler.
+
+        // // SAFETY: see comment above
+        // unsafe { drop_in_place_glue(to_drop) }
+    }
 
-    // SAFETY: see comment above
-    unsafe { drop_in_place(to_drop) }
+    // SAFETY:
+    // - compiler glue has the same safety requirements as this function
+    // - the pointer must be valid as per the safety requirement of this function
+    unsafe { drop_in_place_glue(&mut *to_drop) }
 }
 
 /// Creates a null raw pointer.

tests/codegen-llvm/inline-hint.rs

@@ -16,7 +16,7 @@ pub fn f() {
 
 struct A(String, String);
 
-// CHECK:      ; core::ptr::drop_in_place::<inline_hint::A>
+// CHECK:      ; core::ptr::drop_in_place::drop_in_place_glue::<inline_hint::A>
 // CHECK-NEXT: ; Function Attrs:
 // CHECK-NOT:  inlinehint
 // CHECK-SAME: {{$}}

tests/codegen-llvm/sanitizer/cfi/emit-type-metadata-id-itanium-cxx-abi-drop-in-place.rs

@@ -9,9 +9,9 @@
 
 #![crate_type = "lib"]
 
-// CHECK-LABEL: define{{.*}}4core3ptr13drop_in_placeDNtNtB4_6marker4Send
+// CHECK-LABEL: define{{.*}}4core3ptr13drop_in_place18drop_in_place_glueDNtNtB6_6marker4Send
 // CHECK-SAME:  {{.*}}!type ![[TYPE1:[0-9]+]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
-// CHECK:       call i1 @llvm.type.test(ptr {{%.+}}, metadata !"_ZTSFvPu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops4drop4Dropu6regionEE")
+// CHECK:       call i1 @llvm.type.test(ptr {{%.+}}, metadata !"_ZTSFvU3mutu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops4drop4Dropu6regionEEE")
 
 struct EmptyDrop;
 // CHECK-NOT: define{{.*}}4core3ptr{{[0-9]+}}drop_in_place$LT${{.*}}EmptyDrop$GT${{.*}}!type ![[TYPE1]] !type !{{[0-9]+}} !type !{{[0-9]+}} !type !{{[0-9]+}}
@@ -28,4 +28,4 @@ pub fn foo() {
     let _ = Box::new(PresentDrop) as Box<dyn Send>;
 }
 
-// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvPu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops4drop4Dropu6regionEE"}
+// CHECK: ![[TYPE1]] = !{i64 0, !"_ZTSFvU3mutu3refIu3dynIu{{[0-9]+}}NtNtNtC{{[[:print:]]+}}_4core3ops4drop4Dropu6regionEEE"}

tests/ui/consts/const-eval/c-variadic-fail.stderr

@@ -240,7 +240,7 @@ LL |         drop(ap);
    |         ^^^^^^^^
 note: inside `std::mem::drop::<VaList<'_>>`
   --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-note: inside `drop_in_place::<VaList<'_>> - shim(Some(VaList<'_>))`
+note: inside `drop_in_place::drop_in_place_glue::<VaList<'_>> - shim(Some(VaList<'_>))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `<VaList<'_> as Drop>::drop`
   --> $SRC_DIR/core/src/ffi/va_list.rs:LL:COL
@@ -272,7 +272,7 @@ LL |         drop(ap);
    |         ^^^^^^^^
 note: inside `std::mem::drop::<VaList<'_>>`
   --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-note: inside `drop_in_place::<VaList<'_>> - shim(Some(VaList<'_>))`
+note: inside `drop_in_place::drop_in_place_glue::<VaList<'_>> - shim(Some(VaList<'_>))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `<VaList<'_> as Drop>::drop`
   --> $SRC_DIR/core/src/ffi/va_list.rs:LL:COL
@@ -325,7 +325,7 @@ error[E0080]: pointer not dereferenceable: pointer must point to some allocation
 LL |     }
    |     ^ evaluation of `drop_of_invalid::{constant#0}` failed inside this call
    |
-note: inside `drop_in_place::<VaList<'_>> - shim(Some(VaList<'_>))`
+note: inside `drop_in_place::drop_in_place_glue::<VaList<'_>> - shim(Some(VaList<'_>))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 note: inside `<VaList<'_> as Drop>::drop`
   --> $SRC_DIR/core/src/ffi/va_list.rs:LL:COL

tests/ui/consts/miri_unleashed/assoc_const.stderr

@@ -4,9 +4,9 @@ error[E0080]: calling non-const function `<Vec<u32> as Drop>::drop`
 LL |     const F: u32 = (U::X, 42).1;
    |                               ^ evaluation of `<std::string::String as Bar<std::vec::Vec<u32>, std::string::String>>::F` failed inside this call
    |
-note: inside `drop_in_place::<(Vec<u32>, u32)> - shim(Some((Vec<u32>, u32)))`
+note: inside `drop_in_place::drop_in_place_glue::<(Vec<u32>, u32)> - shim(Some((Vec<u32>, u32)))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `drop_in_place::<Vec<u32>> - shim(Some(Vec<u32>))`
+note: inside `drop_in_place::drop_in_place_glue::<Vec<u32>> - shim(Some(Vec<u32>))`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 
 note: erroneous constant encountered