Ban ArrayToPointer and MutToConstPointer from runtime MIR

Apparently MIR borrowck cares about at least one of these for checking variance.

In runtime MIR, though, there's no need for them as `PtrToPtr` does the same thing.

(Banning them simplifies passes like GVN that no longer need to handle multiple cast possibilities.)

Author: scottmcm

compiler/rustc_middle/src/mir/syntax.rs

@@ -143,6 +143,9 @@ pub enum RuntimePhase {
     /// * [`TerminatorKind::CoroutineDrop`]
     /// * [`Rvalue::Aggregate`] for any `AggregateKind` except `Array`
     /// * [`PlaceElem::OpaqueCast`]
+    /// * [`CastKind::PointerCoercion`] with any of the following:
+    ///   * [`PointerCoercion::ArrayToPointer`]
+    ///   * [`PointerCoercion::MutToConstPointer`]
     ///
     /// And the following variants are allowed:
     /// * [`StatementKind::Retag`]
@@ -1281,8 +1284,7 @@ pub enum Rvalue<'tcx> {
     ///
     /// This allows for casts from/to a variety of types.
     ///
-    /// **FIXME**: Document exactly which `CastKind`s allow which types of casts. Figure out why
-    /// `ArrayToPointer` and `MutToConstPointer` are special.
+    /// **FIXME**: Document exactly which `CastKind`s allow which types of casts.
     Cast(CastKind, Operand<'tcx>, Ty<'tcx>),
 
     /// * `Offset` has the same semantics as [`offset`](pointer::offset), except that the second
@@ -1362,6 +1364,12 @@ pub enum CastKind {
     PointerWithExposedProvenance,
     /// Pointer related casts that are done by coercions. Note that reference-to-raw-ptr casts are
     /// translated into `&raw mut/const *r`, i.e., they are not actually casts.
+    ///
+    /// The following are allowed in analysis MIR (for borrowck), but are forbidden in runtime MIR:
+    /// * [`PointerCoercion::ArrayToPointer`]
+    /// * [`PointerCoercion::MutToConstPointer`]
+    ///
+    /// Both are runtime nops, so should be [`CastKind::PtrToPtr`] instead in runtime MIR.
     PointerCoercion(PointerCoercion),
     /// Cast into a dyn* object.
     DynStar,

compiler/rustc_mir_transform/src/coercions_to_casts.rs

@@ -0,0 +1,24 @@
+use rustc_middle::mir::*;
+use rustc_middle::ty::adjustment::PointerCoercion;
+use rustc_middle::ty::TyCtxt;
+
+/// This pass turns the `PointerCoercion` variants which are disallowed in runtime MIR
+/// into ordinary `PtrToPtr` casts instead.
+pub struct CoercionsToCasts;
+
+impl<'tcx> MirPass<'tcx> for CoercionsToCasts {
+    fn run_pass(&self, _tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
+        for block in body.basic_blocks.as_mut_preserves_cfg() {
+            for statement in block.statements.iter_mut() {
+                if let StatementKind::Assign(box (_place, rvalue)) = &mut statement.kind
+                    && let Rvalue::Cast(cast_kind, ..) = rvalue
+                    && let CastKind::PointerCoercion(
+                        PointerCoercion::ArrayToPointer | PointerCoercion::MutToConstPointer,
+                    ) = cast_kind
+                {
+                    *cast_kind = CastKind::PtrToPtr;
+                }
+            }
+        }
+    }
+}

compiler/rustc_mir_transform/src/gvn.rs

@@ -572,11 +572,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                     let ret = self.ecx.ptr_to_ptr(&src, to).ok()?;
                     ret.into()
                 }
-                CastKind::PointerCoercion(
-                    ty::adjustment::PointerCoercion::MutToConstPointer
-                    | ty::adjustment::PointerCoercion::ArrayToPointer
-                    | ty::adjustment::PointerCoercion::UnsafeFnPointer,
-                ) => {
+                CastKind::PointerCoercion(ty::adjustment::PointerCoercion::UnsafeFnPointer) => {
                     let src = self.evaluated[value].as_ref()?;
                     let src = self.ecx.read_immediate(src).ok()?;
                     let to = self.ecx.layout_of(to).ok()?;
@@ -1165,10 +1161,10 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             }
         }
 
-        if let PtrToPtr | PointerCoercion(MutToConstPointer) = kind
+        if let PtrToPtr = kind
             && let Value::Cast { kind: inner_kind, value: inner_value, from: inner_from, to: _ } =
                 *self.get(value)
-            && let PtrToPtr | PointerCoercion(MutToConstPointer) = inner_kind
+            && let PtrToPtr = inner_kind
         {
             from = inner_from;
             value = inner_value;

compiler/rustc_mir_transform/src/lib.rs

@@ -49,12 +49,13 @@ mod abort_unwinding_calls;
 mod add_call_guards;
 mod add_moves_for_packed_drops;
 mod add_retag;
+mod add_subtyping_projections;
+mod check_alignment;
 mod check_const_item_mutation;
 mod check_packed_ref;
-mod remove_place_mention;
 // This pass is public to allow external drivers to perform MIR cleanup
-mod add_subtyping_projections;
 pub mod cleanup_post_borrowck;
+mod coercions_to_casts;
 mod copy_prop;
 mod coroutine;
 mod cost_checker;
@@ -92,6 +93,7 @@ mod prettify;
 mod promote_consts;
 mod ref_prop;
 mod remove_noop_landing_pads;
+mod remove_place_mention;
 mod remove_storage_markers;
 mod remove_uninit_drops;
 mod remove_unneeded_drops;
@@ -101,7 +103,6 @@ mod reveal_all;
 mod shim;
 mod ssa;
 // This pass is public to allow external drivers to perform MIR cleanup
-mod check_alignment;
 pub mod simplify;
 mod simplify_branches;
 mod simplify_comparison_integral;
@@ -506,6 +507,7 @@ fn run_analysis_cleanup_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
 /// Returns the sequence of passes that lowers analysis to runtime MIR.
 fn run_runtime_lowering_passes<'tcx>(tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
     let passes: &[&dyn MirPass<'tcx>] = &[
+        &coercions_to_casts::CoercionsToCasts,
         // These next passes must be executed together
         &add_call_guards::CriticalCallEdges,
         &reveal_all::RevealAll, // has to be done before drop elaboration, since we need to drop opaque types, too.

compiler/rustc_mir_transform/src/validate.rs

@@ -1187,6 +1187,9 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             "CastKind::{kind:?} output must be a raw const pointer, not {:?}",
                             ty::RawPtr(_, Mutability::Not)
                         );
+                        if let MirPhase::Runtime(..) = self.mir_phase {
+                            self.fail(location, format!("Runtime MIR disallows {kind:?}"));
+                        }
                     }
                     CastKind::PointerCoercion(PointerCoercion::ArrayToPointer) => {
                         // FIXME: Check pointee types
@@ -1200,6 +1203,9 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                             "CastKind::{kind:?} output must be a raw pointer, not {:?}",
                             ty::RawPtr(..)
                         );
+                        if let MirPhase::Runtime(..) = self.mir_phase {
+                            self.fail(location, format!("Runtime MIR disallows {kind:?}"));
+                        }
                     }
                     CastKind::PointerCoercion(PointerCoercion::Unsize) => {
                         // This is used for all `CoerceUnsized` types,
@@ -1211,7 +1217,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                         if !input_valid || !target_valid {
                             self.fail(
                                 location,
-                                format!("Wrong cast kind {kind:?} for the type {op_ty}",),
+                                format!("Wrong cast kind {kind:?} for the type {op_ty}"),
                             );
                         }
                     }

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-abort.diff

@@ -80,7 +80,7 @@
 
       bb4: {
           StorageDead(_8);
--         _11 = _6 as *const [bool; 0] (PointerCoercion(MutToConstPointer));
+-         _11 = _6 as *const [bool; 0] (PtrToPtr);
 -         _5 = NonNull::<[bool; 0]> { pointer: _11 };
 +         _11 = const {0x1 as *const [bool; 0]};
 +         _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.32bit.panic-unwind.diff

@@ -84,7 +84,7 @@
 
       bb5: {
           StorageDead(_8);
--         _11 = _6 as *const [bool; 0] (PointerCoercion(MutToConstPointer));
+-         _11 = _6 as *const [bool; 0] (PtrToPtr);
 -         _5 = NonNull::<[bool; 0]> { pointer: _11 };
 +         _11 = const {0x1 as *const [bool; 0]};
 +         _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-abort.diff

@@ -80,7 +80,7 @@
 
       bb4: {
           StorageDead(_8);
--         _11 = _6 as *const [bool; 0] (PointerCoercion(MutToConstPointer));
+-         _11 = _6 as *const [bool; 0] (PtrToPtr);
 -         _5 = NonNull::<[bool; 0]> { pointer: _11 };
 +         _11 = const {0x1 as *const [bool; 0]};
 +         _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};

tests/mir-opt/dataflow-const-prop/default_boxed_slice.main.GVN.64bit.panic-unwind.diff

@@ -84,7 +84,7 @@
 
       bb5: {
           StorageDead(_8);
--         _11 = _6 as *const [bool; 0] (PointerCoercion(MutToConstPointer));
+-         _11 = _6 as *const [bool; 0] (PtrToPtr);
 -         _5 = NonNull::<[bool; 0]> { pointer: _11 };
 +         _11 = const {0x1 as *const [bool; 0]};
 +         _5 = const NonNull::<[bool; 0]> {{ pointer: {0x1 as *const [bool; 0]} }};

tests/mir-opt/instsimplify/casts.roundtrip.InstSimplify.diff

@@ -14,7 +14,7 @@
           StorageLive(_4);
           _4 = _1;
           _3 = move _4 as *mut u8 (PtrToPtr);
-          _2 = move _3 as *const u8 (PointerCoercion(MutToConstPointer));
+          _2 = move _3 as *const u8 (PtrToPtr);
           StorageDead(_4);
           StorageDead(_3);
 -         _0 = move _2 as *const u8 (PtrToPtr);

tests/mir-opt/instsimplify/casts.rs

@@ -21,7 +21,7 @@ pub fn roundtrip(x: *const u8) -> *const u8 {
     // CHECK-LABEL: fn roundtrip(
     // CHECK: _4 = _1;
     // CHECK: _3 = move _4 as *mut u8 (PtrToPtr);
-    // CHECK: _2 = move _3 as *const u8 (PointerCoercion(MutToConstPointer));
+    // CHECK: _2 = move _3 as *const u8 (PtrToPtr);
     x as *mut u8 as *const u8
 }
 

tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir

@@ -79,7 +79,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }

tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-unwind.mir

@@ -79,7 +79,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }

tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir

@@ -71,7 +71,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }

tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir

@@ -71,7 +71,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }

tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-abort.mir

@@ -79,7 +79,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }

tests/mir-opt/pre-codegen/slice_iter.reverse_loop.PreCodegen.after.panic-unwind.mir

@@ -79,7 +79,7 @@ fn reverse_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         _7 = _4 as *mut T (PtrToPtr);
         _8 = Offset(_7, _3);
         StorageDead(_7);
-        _9 = move _8 as *const T (PointerCoercion(MutToConstPointer));
+        _9 = move _8 as *const T (PtrToPtr);
         StorageDead(_8);
         goto -> bb3;
     }

tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-abort.mir

@@ -64,7 +64,7 @@ fn array_casts() -> () {
         StorageLive(_4);
         _4 = &mut _1;
         _3 = &raw mut (*_4);
-        _2 = move _3 as *mut usize (PointerCoercion(ArrayToPointer));
+        _2 = move _3 as *mut usize (PtrToPtr);
         StorageDead(_3);
         StorageDead(_4);
         StorageLive(_5);
@@ -87,7 +87,7 @@ fn array_casts() -> () {
         StorageLive(_11);
         _11 = &_8;
         _10 = &raw const (*_11);
-        _9 = move _10 as *const usize (PointerCoercion(ArrayToPointer));
+        _9 = move _10 as *const usize (PtrToPtr);
         StorageDead(_10);
         StorageDead(_11);
         StorageLive(_12);

tests/mir-opt/retag.array_casts.SimplifyCfg-pre-optimizations.after.panic-unwind.mir

@@ -64,7 +64,7 @@ fn array_casts() -> () {
         StorageLive(_4);
         _4 = &mut _1;
         _3 = &raw mut (*_4);
-        _2 = move _3 as *mut usize (PointerCoercion(ArrayToPointer));
+        _2 = move _3 as *mut usize (PtrToPtr);
         StorageDead(_3);
         StorageDead(_4);
         StorageLive(_5);
@@ -87,7 +87,7 @@ fn array_casts() -> () {
         StorageLive(_11);
         _11 = &_8;
         _10 = &raw const (*_11);
-        _9 = move _10 as *const usize (PointerCoercion(ArrayToPointer));
+        _9 = move _10 as *const usize (PtrToPtr);
         StorageDead(_10);
         StorageDead(_11);
         StorageLive(_12);