Add ptr::read_move

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -384,6 +384,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
             sym::unlikely => (0, vec![tcx.types.bool], tcx.types.bool),
 
             sym::read_via_copy => (1, vec![tcx.mk_imm_ptr(param(0))], param(0)),
+            sym::read_via_move => (1, vec![tcx.mk_imm_ptr(param(0))], param(0)),
             sym::write_via_move => (1, vec![tcx.mk_mut_ptr(param(0)), param(0)], tcx.mk_unit()),
 
             sym::discriminant_value => {

compiler/rustc_mir_transform/src/lower_intrinsics.rs

@@ -165,7 +165,7 @@ impl<'tcx> MirPass<'tcx> for LowerIntrinsics {
                             terminator.kind = TerminatorKind::Goto { target };
                         }
                     }
-                    sym::read_via_copy => {
+                    sym::read_via_copy | sym::read_via_move => {
                         let [arg] = args.as_slice() else {
                             span_bug!(terminator.source_info.span, "Wrong number of arguments");
                         };
@@ -183,11 +183,16 @@ impl<'tcx> MirPass<'tcx> for LowerIntrinsics {
                                 TerminatorKind::Unreachable
                             }
                             Some(target) => {
+                                let operand = if intrinsic_name == sym::read_via_copy {
+                                    Operand::Copy(derefed_place)
+                                } else {
+                                    Operand::Move(derefed_place)
+                                };
                                 block.statements.push(Statement {
                                     source_info: terminator.source_info,
                                     kind: StatementKind::Assign(Box::new((
                                         *destination,
-                                        Rvalue::Use(Operand::Copy(derefed_place)),
+                                        Rvalue::Use(operand),
                                     ))),
                                 });
                                 TerminatorKind::Goto { target }

compiler/rustc_span/src/symbol.rs

@@ -1182,6 +1182,7 @@ symbols! {
         read_struct,
         read_struct_field,
         read_via_copy,
+        read_via_move,
         readonly,
         realloc,
         reason,

library/core/src/intrinsics.rs

@@ -2272,6 +2272,16 @@ extern "rust-intrinsic" {
     #[rustc_nounwind]
     pub fn read_via_copy<T>(ptr: *const T) -> T;
 
+    /// This is an implementation detail of [`crate::ptr::read_move`] and should
+    /// not be used anywhere else.
+    ///
+    /// This intrinsic can *only* be called where the pointer is a local without
+    /// projections (`read_via_move(ptr)`, not `read_via_move(*ptr)`) so that it
+    /// trivially obeys runtime-MIR rules about derefs in operands.
+    #[rustc_nounwind]
+    #[cfg(not(bootstrap))]
+    pub fn read_via_move<T>(ptr: *mut T) -> T;
+
     /// This is an implementation detail of [`crate::ptr::write`] and should
     /// not be used anywhere else.  See its comments for why this exists.
     ///

library/core/src/ptr/mod.rs

@@ -1180,6 +1180,38 @@ pub const unsafe fn read<T>(src: *const T) -> T {
     }
 }
 
+/// Reads the value from `src` by moving it.
+///
+/// # Safety
+///
+/// Behavior is undefined if any of the following conditions are violated:
+///
+/// * `src` must be [valid] for reads.
+///
+/// * `src` must be properly aligned.
+///
+/// * `src` must point to a properly initialized value of type `T`.
+///
+/// * `src` must not be read or written while the return value exists.
+///
+/// Note that even if `T` has size `0`, the pointer must be non-null and properly aligned.
+///
+/// [valid]: self#safety
+#[inline]
+#[rustc_const_unstable(feature = "read_move", issue = "none")]
+#[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
+#[cfg(not(bootstrap))]
+pub const unsafe fn read_move<T>(src: *mut T) -> T {
+    // SAFETY: the caller must guarantee that `src` is valid for reads.
+    unsafe {
+        assert_unsafe_precondition!(
+            "ptr::read_move requires that the pointer argument is aligned and non-null",
+            [T](src: *mut T) => is_aligned_and_not_null(src)
+        );
+        crate::intrinsics::read_via_move(src)
+    }
+}
+
 /// Reads the value from `src` without moving it. This leaves the
 /// memory in `src` unchanged.
 ///