Only mark the first pointer-width bytes of TypeIdwith provenance

Author: oli-obk

compiler/rustc_codegen_llvm/src/common.rs

@@ -4,17 +4,15 @@ use std::borrow::Borrow;
 
 use libc::{c_char, c_uint};
 use rustc_abi::Primitive::Pointer;
-use rustc_abi::{self as abi, Align, HasDataLayout as _, Size};
+use rustc_abi::{self as abi, HasDataLayout as _};
 use rustc_ast::Mutability;
 use rustc_codegen_ssa::common::TypeKind;
 use rustc_codegen_ssa::traits::*;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_hashes::Hash128;
 use rustc_hir::def_id::DefId;
 use rustc_middle::bug;
-use rustc_middle::mir::interpret::{
-    AllocInit, Allocation, ConstAllocation, GlobalAlloc, Scalar, alloc_range,
-};
+use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::cstore::DllImport;
 use tracing::debug;
@@ -326,28 +324,9 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                         assert!(!self.tcx.is_thread_local_static(def_id));
                         self.get_static(def_id)
                     }
-                    GlobalAlloc::Type { ty, segment } => {
-                        let type_id = self.tcx.type_id_hash(ty).as_u128();
-                        let mut alloc: Allocation = Allocation::new(
-                            Size::from_bytes(16),
-                            Align::from_bytes(8).unwrap(),
-                            AllocInit::Uninit,
-                            (),
-                        );
-                        alloc
-                            .write_scalar(
-                                &self.tcx,
-                                alloc_range(Size::ZERO, Size::from_bytes(16)),
-                                Scalar::from_u128(type_id),
-                            )
-                            .unwrap();
-                        let pointer_size = self.tcx.data_layout.pointer_size;
-                        let offset = pointer_size * u64::from(segment);
-                        let value = alloc
-                            .read_scalar(&self.tcx, alloc_range(offset, pointer_size), false)
-                            .unwrap();
-                        let data = value.to_bits(pointer_size).unwrap() as u64;
-                        let llval = self.const_usize(data);
+                    GlobalAlloc::Type { .. } => {
+                        // Drop the provenance, the offset contains the bytes of the hash
+                        let llval = self.const_usize(offset.bytes());
                         return unsafe { llvm::LLVMConstIntToPtr(llval, llty) };
                     }
                 };

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -406,33 +406,20 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
             sym::type_id_eq => {
                 let a = ecx.project_field(&args[0], FieldIdx::ZERO)?;
                 let b = ecx.project_field(&args[1], FieldIdx::ZERO)?;
-                let mut eq = true;
-                for index in 0..(16 / ecx.tcx.data_layout.pointer_size.bytes()) {
-                    let a = ecx.project_index(&a, index)?;
-                    let a = ecx.deref_pointer(&a)?;
-                    let (a, offset) = a.ptr().into_parts();
-                    assert_eq!(offset, Size::ZERO);
-                    let a = a.unwrap().alloc_id();
-                    let GlobalAlloc::Type { ty: a, segment: a_segment } = ecx.tcx.global_alloc(a)
-                    else {
-                        bug!()
-                    };
-                    let b = ecx.project_index(&b, index)?;
-                    let b = ecx.deref_pointer(&b)?;
-                    let (b, offset) = b.ptr().into_parts();
-                    assert_eq!(offset, Size::ZERO);
-                    let b = b.unwrap().alloc_id();
-                    let GlobalAlloc::Type { ty: b, segment: b_segment } = ecx.tcx.global_alloc(b)
-                    else {
-                        bug!()
-                    };
-
-                    eq &= a == b && a_segment == b_segment;
-                    if !eq {
-                        break;
-                    }
-                }
-                ecx.write_scalar(Scalar::from_bool(eq), dest)?;
+
+                let a = ecx.project_index(&a, 0)?;
+                let a = ecx.deref_pointer(&a)?;
+                let (a, offset_a) = a.ptr().into_parts();
+                let a = a.unwrap().alloc_id();
+                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) = b.ptr().into_parts();
+                let b = b.unwrap().alloc_id();
+                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)?;

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -36,13 +36,26 @@ pub(crate) fn alloc_type_id<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> AllocId {
     let align = tcx.data_layout.pointer_align;
     let mut alloc = Allocation::new(size, *align, AllocInit::Uninit, ());
     let ptr_size = tcx.data_layout.pointer_size;
-    for step in 0..size.bytes() / ptr_size.bytes() {
-        let offset = ptr_size * step;
-        let alloc_id = tcx.reserve_and_set_type_id_alloc(ty, step.try_into().unwrap());
-        let ptr = Pointer::new(alloc_id.into(), Size::ZERO);
-        let val = Scalar::from_pointer(ptr, &tcx);
-        alloc.write_scalar(&tcx, alloc_range(offset, ptr_size), val).unwrap();
-    }
+    let type_id_hash = tcx.type_id_hash(ty).as_u128();
+    alloc
+        .write_scalar(
+            &tcx,
+            alloc_range(Size::ZERO, Size::from_bytes(16)),
+            Scalar::from_u128(type_id_hash),
+        )
+        .unwrap();
+
+    // Give the first pointer-size bytes provenance that knows about the type id
+
+    let alloc_id = tcx.reserve_and_set_type_id_alloc(ty);
+    let offset = alloc
+        .read_scalar(&tcx, alloc_range(Size::ZERO, ptr_size), false)
+        .unwrap()
+        .to_target_usize(&tcx)
+        .unwrap();
+    let ptr = Pointer::new(alloc_id.into(), Size::from_bytes(offset));
+    let val = Scalar::from_pointer(ptr, &tcx);
+    alloc.write_scalar(&tcx, alloc_range(Size::ZERO, ptr_size), val).unwrap();
 
     alloc.mutability = Mutability::Not;
 

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -1211,8 +1211,8 @@ impl<'a, 'tcx, M: Machine<'tcx>> std::fmt::Debug for DumpAllocs<'a, 'tcx, M> {
                         Some(GlobalAlloc::VTable(ty, dyn_ty)) => {
                             write!(fmt, " (vtable: impl {dyn_ty} for {ty})")?;
                         }
-                        Some(GlobalAlloc::Type { ty, segment }) => {
-                            write!(fmt, " (typeid segment {segment } for {ty})")?;
+                        Some(GlobalAlloc::Type { ty }) => {
+                            write!(fmt, " (typeid for {ty})")?;
                         }
                         Some(GlobalAlloc::Static(did)) => {
                             write!(fmt, " (static: {})", self.ecx.tcx.def_path_str(did))?;

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -128,11 +128,10 @@ pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<'tcx>>(
             ty.encode(encoder);
             poly_trait_ref.encode(encoder);
         }
-        GlobalAlloc::Type { ty, segment } => {
+        GlobalAlloc::Type { ty } => {
             trace!("encoding {alloc_id:?} with {ty:#?}");
             AllocDiscriminant::Type.encode(encoder);
             ty.encode(encoder);
-            segment.encode(encoder);
         }
         GlobalAlloc::Static(did) => {
             assert!(!tcx.is_thread_local_static(did));
@@ -238,9 +237,8 @@ impl<'s> AllocDecodingSession<'s> {
             AllocDiscriminant::Type => {
                 trace!("creating typeid alloc ID");
                 let ty = Decodable::decode(decoder);
-                let segment = Decodable::decode(decoder);
-                trace!("decoded typid: {ty:?} ({segment})");
-                decoder.interner().reserve_and_set_type_id_alloc(ty, segment)
+                trace!("decoded typid: {ty:?}");
+                decoder.interner().reserve_and_set_type_id_alloc(ty)
             }
             AllocDiscriminant::Static => {
                 trace!("creating extern static alloc ID");
@@ -272,9 +270,9 @@ pub enum GlobalAlloc<'tcx> {
     Static(DefId),
     /// The alloc ID points to memory.
     Memory(ConstAllocation<'tcx>),
-    /// A pointer-sized segment of a type id. On 64 bit systems, the 128 bit type id
+    /// The first pointer-sized segment of a type id. On 64 bit systems, the 128 bit type id
     /// is split into two segments, on 32 bit systems there are 4 segments, and so on.
-    Type { ty: Ty<'tcx>, segment: u8 },
+    Type { ty: Ty<'tcx> },
 }
 
 impl<'tcx> GlobalAlloc<'tcx> {
@@ -508,8 +506,8 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     /// Generates an [AllocId] for a [core::mem::type_info::TypeId]. Will get deduplicated.
-    pub fn reserve_and_set_type_id_alloc(self, ty: Ty<'tcx>, segment: u8) -> AllocId {
-        self.reserve_and_set_dedup(GlobalAlloc::Type { ty, segment }, 0)
+    pub fn reserve_and_set_type_id_alloc(self, ty: Ty<'tcx>) -> AllocId {
+        self.reserve_and_set_dedup(GlobalAlloc::Type { ty }, 0)
     }
 
     /// Interns the `Allocation` and return a new `AllocId`, even if there's already an identical

compiler/rustc_middle/src/mir/pretty.rs

@@ -1621,9 +1621,7 @@ pub fn write_allocations<'tcx>(
             Some(GlobalAlloc::VTable(ty, dyn_ty)) => {
                 write!(w, " (vtable: impl {dyn_ty} for {ty})")?
             }
-            Some(GlobalAlloc::Type { ty, segment }) => {
-                write!(w, " (typeid segment {segment} for {ty})")?
-            }
+            Some(GlobalAlloc::Type { ty }) => write!(w, " (typeid for {ty})")?,
             Some(GlobalAlloc::Static(did)) if !tcx.is_foreign_item(did) => {
                 write!(w, " (static: {}", tcx.def_path_str(did))?;
                 if body.phase <= MirPhase::Runtime(RuntimePhase::PostCleanup)

library/core/src/any.rs

@@ -709,7 +709,7 @@ impl dyn Any + Send + Sync {
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang = "type_id"]
 pub struct TypeId {
-    data: [*const (); 16 / size_of::<usize>()],
+    pub(crate) data: [*const (); 16 / size_of::<usize>()],
 }
 
 // SAFETY: the raw pointer is always an integer
@@ -724,30 +724,7 @@ unsafe impl Sync for TypeId {}
 impl const PartialEq for TypeId {
     #[inline]
     fn eq(&self, other: &Self) -> bool {
-        const fn ct(a: &TypeId, b: &TypeId) -> bool {
-            crate::intrinsics::type_id_eq(*a, *b)
-        }
-
-        #[inline]
-        fn rt(a: &TypeId, b: &TypeId) -> bool {
-            a.data == b.data
-        }
-
-        core::intrinsics::const_eval_select((self, other), ct, rt)
-    }
-
-    #[inline]
-    fn ne(&self, other: &Self) -> bool {
-        const fn ct(a: &TypeId, b: &TypeId) -> bool {
-            !crate::intrinsics::type_id_eq(*a, *b)
-        }
-
-        #[inline]
-        fn rt(a: &TypeId, b: &TypeId) -> bool {
-            a.data != b.data
-        }
-
-        core::intrinsics::const_eval_select((self, other), ct, rt)
+        crate::intrinsics::type_id_eq(*self, *other)
     }
 }
 

library/core/src/intrinsics/mod.rs

@@ -2728,8 +2728,12 @@ pub const fn type_id<T: ?Sized + 'static>() -> crate::any::TypeId;
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-pub const fn type_id_eq(_a: crate::any::TypeId, _b: crate::any::TypeId) -> bool {
-    panic!("type_id_eq should only be used from const eval")
+// The intrinsic is always overridden by CTFE and we don't want to limit the default body to
+// const operations only, as that would require transmuting the raw pointers to usize because
+// you can't do that cast in CTFE.
+#[rustc_do_not_const_check]
+pub const fn type_id_eq(a: crate::any::TypeId, b: crate::any::TypeId) -> bool {
+    a.data == b.data
 }
 
 /// Lowers in MIR to `Rvalue::Aggregate` with `AggregateKind::RawPtr`.