Unify the miri and ctfe type id equality checks

Author: oli-obk

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -2,7 +2,7 @@ use std::borrow::{Borrow, Cow};
 use std::fmt;
 use std::hash::Hash;
 
-use rustc_abi::{Align, FieldIdx, Size};
+use rustc_abi::{Align, Size};
 use rustc_ast::Mutability;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap, IndexEntry};
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -403,22 +403,6 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                 let cmp = ecx.guaranteed_cmp(a, b)?;
                 ecx.write_scalar(Scalar::from_u8(cmp), dest)?;
             }
-            sym::type_id_eq => {
-                let a = ecx.project_field(&args[0], FieldIdx::ZERO)?;
-                let b = ecx.project_field(&args[1], FieldIdx::ZERO)?;
-
-                let a = ecx.project_index(&a, 0)?;
-                let a = ecx.deref_pointer(&a)?;
-                let (a, offset_a, _) = ecx.ptr_get_alloc_id(a.ptr(), 0)?;
-                let GlobalAlloc::Type { ty: a } = ecx.tcx.global_alloc(a) else { bug!() };
-
-                let b = ecx.project_index(&b, 0)?;
-                let b = ecx.deref_pointer(&b)?;
-                let (b, offset_b, _) = ecx.ptr_get_alloc_id(b.ptr(), 0)?;
-                let GlobalAlloc::Type { ty: b } = ecx.tcx.global_alloc(b) else { bug!() };
-
-                ecx.write_scalar(Scalar::from_bool(a == b && offset_a == offset_b), dest)?;
-            }
             sym::const_allocate => {
                 let size = ecx.read_scalar(&args[0])?.to_target_usize(ecx)?;
                 let align = ecx.read_scalar(&args[1])?.to_target_usize(ecx)?;

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -6,6 +6,7 @@ use std::assert_matches::assert_matches;
 
 use rustc_abi::{FieldIdx, Size};
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
+use rustc_middle::mir::interpret::GlobalAlloc;
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{Ty, TyCtxt};
@@ -92,6 +93,47 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 ensure_monomorphic_enough(tcx, tp_ty)?;
                 self.write_type_id(tp_ty, dest)?;
             }
+            sym::type_id_eq => {
+                let a_fields = self.project_field(&args[0], FieldIdx::ZERO)?;
+                let b_fields = self.project_field(&args[1], FieldIdx::ZERO)?;
+
+                let mut a_fields = self.project_array_fields(&a_fields)?;
+
+                let mut b_fields = self.project_array_fields(&b_fields)?;
+
+                let (_idx, a) = a_fields
+                    .next(self)?
+                    .expect("we know the layout of TypeId has at least 2 array elements");
+                let a = self.deref_pointer(&a)?;
+                let (a, offset_a, _) = self.ptr_get_alloc_id(a.ptr(), 0)?;
+                let GlobalAlloc::Type { ty: a } = self.tcx.global_alloc(a) else { bug!() };
+
+                let (_idx, b) = b_fields
+                    .next(self)?
+                    .expect("we know the layout of TypeId has at least 2 array elements");
+                let b = self.deref_pointer(&b)?;
+                let (b, offset_b, _) = self.ptr_get_alloc_id(b.ptr(), 0)?;
+                let GlobalAlloc::Type { ty: b } = self.tcx.global_alloc(b) else { bug!() };
+
+                let provenance_matches = a == b;
+
+                if offset_a != offset_b && provenance_matches {
+                    throw_ub_format!("modifying `TypeId` internals is not permitted")
+                }
+
+                while let Some((_, a)) = a_fields.next(self)? {
+                    let (_, b) = b_fields.next(self)?.unwrap();
+
+                    let a = self.read_target_usize(&a)?;
+                    let b = self.read_target_usize(&b)?;
+
+                    if a != b && provenance_matches {
+                        throw_ub_format!("modifying `TypeId` internals is not permitted")
+                    }
+                }
+
+                self.write_scalar(Scalar::from_bool(provenance_matches), dest)?;
+            }
             sym::variant_count => {
                 let tp_ty = instance.args.type_at(0);
                 let ty = match tp_ty.kind() {

compiler/rustc_const_eval/src/interpret/projection.rs

@@ -296,7 +296,11 @@ where
         base: &'a P,
     ) -> InterpResult<'tcx, ArrayIterator<'a, 'tcx, M::Provenance, P>> {
         let abi::FieldsShape::Array { stride, .. } = base.layout().fields else {
-            span_bug!(self.cur_span(), "project_array_fields: expected an array layout");
+            span_bug!(
+                self.cur_span(),
+                "project_array_fields: expected an array layout, got {:#?}",
+                base.layout()
+            );
         };
         let len = base.len(self)?;
         let field_layout = base.layout().field(self, 0);

src/tools/miri/src/intrinsics/mod.rs

@@ -6,7 +6,7 @@ mod simd;
 use std::ops::Neg;
 
 use rand::Rng;
-use rustc_abi::{FieldIdx, Size};
+use rustc_abi::Size;
 use rustc_apfloat::ieee::{IeeeFloat, Semantics};
 use rustc_apfloat::{self, Float, Round};
 use rustc_middle::mir;
@@ -461,28 +461,6 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Make these a NOP, so we get the better Miri-native error messages.
             }
 
-            "type_id_eq" => {
-                let [a, b] = check_intrinsic_arg_count(args)?;
-
-                let a = this.project_field(a, FieldIdx::ZERO)?;
-                let mut a = this.project_array_fields(&a)?;
-                let b = this.project_field(b, FieldIdx::ZERO)?;
-                let mut b = this.project_array_fields(&b)?;
-
-                while let Some((_, a)) = a.next(this)? {
-                    let (_, b) = b.next(this)?.unwrap();
-
-                    let a = this.read_pointer(&a)?;
-                    let b = this.read_pointer(&b)?;
-
-                    if a != b {
-                        this.write_int(0, dest)?;
-                        return interp_ok(EmulateItemResult::NeedsReturn);
-                    }
-                }
-                this.write_int(1, dest)?;
-            }
-
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
 

tests/ui/consts/const_transmute_type_id2.32bit.stderr

@@ -0,0 +1,14 @@
+error[E0080]: pointer not dereferenceable: pointer must point to some allocation, but got 0xffffffff[noalloc] which is a dangling pointer (it has no provenance)
+  --> $DIR/const_transmute_type_id2.rs:10:13
+   |
+LL |     assert!(a == b);
+   |             ^^^^^^ evaluation of `_` failed inside this call
+   |
+note: inside `<TypeId as PartialEq>::eq`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+note: inside `<TypeId as PartialEq>::eq::ct`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.

tests/ui/consts/const_transmute_type_id2.64bit.stderr

@@ -0,0 +1,14 @@
+error[E0080]: pointer not dereferenceable: pointer must point to some allocation, but got 0xffffffffffffffff[noalloc] which is a dangling pointer (it has no provenance)
+  --> $DIR/const_transmute_type_id2.rs:10:13
+   |
+LL |     assert!(a == b);
+   |             ^^^^^^ evaluation of `_` failed inside this call
+   |
+note: inside `<TypeId as PartialEq>::eq`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+note: inside `<TypeId as PartialEq>::eq::ct`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.

tests/ui/consts/const_transmute_type_id2.rs

@@ -0,0 +1,14 @@
+//@ stderr-per-bitwidth
+
+#![feature(const_type_id, const_trait_impl)]
+
+use std::any::TypeId;
+
+const _: () = {
+    let a: TypeId = unsafe { std::mem::transmute(u128::MAX) };
+    let b: TypeId = unsafe { std::mem::transmute(u128::MAX) };
+    assert!(a == b);
+    //~^ ERROR: pointer must point to some allocation
+};
+
+fn main() {}

tests/ui/consts/const_transmute_type_id3.rs

@@ -0,0 +1,16 @@
+#![feature(const_type_id, const_trait_impl)]
+
+use std::any::TypeId;
+
+const _: () = {
+    let a = TypeId::of::<()>();
+    let mut b = TypeId::of::<()>();
+    unsafe {
+        let ptr = &mut b as *mut TypeId as *mut usize;
+        std::ptr::write(ptr.offset(1), 999);
+    }
+    assert!(a == b);
+    //~^ ERROR: modifying `TypeId` internals is not permitted
+};
+
+fn main() {}

tests/ui/consts/const_transmute_type_id3.stderr

@@ -0,0 +1,14 @@
+error[E0080]: modifying `TypeId` internals is not permitted
+  --> $DIR/const_transmute_type_id3.rs:12:13
+   |
+LL |     assert!(a == b);
+   |             ^^^^^^ evaluation of `_` failed inside this call
+   |
+note: inside `<TypeId as PartialEq>::eq`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+note: inside `<TypeId as PartialEq>::eq::ct`
+  --> $SRC_DIR/core/src/any.rs:LL:COL
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0080`.