Make TypeId robust against compile-time introspection

Author: oli-obk

compiler/rustc_codegen_llvm/src/common.rs

@@ -342,9 +342,19 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                                 Scalar::from_u128(type_id),
                             )
                             .unwrap();
+                        alloc.mutability = Mutability::Not;
                         let init = const_alloc_to_llvm(self, &alloc, /*static*/ false);
                         self.static_addr_of_impl(init, alloc.align, None)
                     }
+                    GlobalAlloc::PartialHash(ty) => {
+                        assert!(matches!(layout.primitive(), Pointer(_)));
+                        let bytes = self.tcx.type_id_hash(ty).truncate().as_u64().to_be_bytes();
+                        let bits = self.tcx.data_layout.pointer_size.bits();
+                        let mask = u64::MAX >> (64 - bits);
+                        // It doesn't matter which bits we pick as long as the scheme is the same with the same compiler.
+                        let llval = self.const_usize(u64::from_be_bytes(bytes) & mask);
+                        return unsafe { llvm::LLVMConstIntToPtr(llval, llty) };
+                    }
                 };
                 let base_addr_space = global_alloc.address_space(self);
                 let llval = unsafe {

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -6,7 +6,9 @@ use std::assert_matches::assert_matches;
 
 use rustc_abi::Size;
 use rustc_apfloat::ieee::{Double, Half, Quad, Single};
+use rustc_ast::Mutability;
 use rustc_hir::def_id::DefId;
+use rustc_middle::mir::interpret::{AllocId, AllocInit, CtfeProvenance, alloc_range};
 use rustc_middle::mir::{self, BinOp, ConstValue, NonDivergingIntrinsic};
 use rustc_middle::ty::layout::{LayoutOf as _, TyAndLayout, ValidityRequirement};
 use rustc_middle::ty::{GenericArgsRef, Ty, TyCtxt};
@@ -30,6 +32,31 @@ pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAll
     tcx.mk_const_alloc(alloc)
 }
 
+pub(crate) fn alloc_type_id<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> AllocId {
+    let ptr_size = tcx.data_layout.pointer_size;
+    let align = tcx.data_layout.pointer_align;
+
+    let mut alloc = Allocation::new(ptr_size * 2, *align, AllocInit::Uninit, ());
+    // Write a pointer pointing to the hash. At ctfe time this is an opaque pointer that you cannot deref
+    let ptr = tcx.reserve_and_set_type_id_alloc(ty);
+    let ptr = Pointer::new(CtfeProvenance::from(ptr), Size::ZERO);
+    alloc
+        .write_scalar(&tcx, alloc_range(Size::ZERO, ptr_size), Scalar::from_pointer(ptr, &tcx))
+        .unwrap();
+
+    // Write a pointer that is not actually a pointer but will just get replaced by the first `pointer_size` bytes of the hash
+    // in codegen. It is a pointer in CTFE so no one can access the bits.
+    let ptr = tcx.reserve_and_set_type_id_partial_hash(ty);
+    let ptr = Pointer::new(CtfeProvenance::from(ptr), Size::ZERO);
+    alloc
+        .write_scalar(&tcx, alloc_range(ptr_size, ptr_size), Scalar::from_pointer(ptr, &tcx))
+        .unwrap();
+
+    alloc.mutability = Mutability::Not;
+
+    tcx.reserve_and_set_memory_alloc(tcx.mk_const_alloc(alloc))
+}
+
 /// The logic for all nullary intrinsics is implemented here. These intrinsics don't get evaluated
 /// inside an `InterpCx` and instead have their value computed directly from rustc internal info.
 pub(crate) fn eval_nullary_intrinsic<'tcx>(
@@ -52,7 +79,8 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
         }
         sym::type_id => {
             ensure_monomorphic_enough(tcx, tp_ty)?;
-            ConstValue::from_u128(tcx.type_id_hash(tp_ty).as_u128())
+            let alloc_id = alloc_type_id(tcx, tp_ty);
+            ConstValue::Indirect { alloc_id, offset: Size::ZERO }
         }
         sym::variant_count => match match tp_ty.kind() {
             // Pattern types have the same number of variants as their base type.

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -353,6 +353,13 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                         kind = "typeid",
                     )
                 }
+                Some(GlobalAlloc::PartialHash(..)) => {
+                    err_ub_custom!(
+                        fluent::const_eval_invalid_dealloc,
+                        alloc_id = alloc_id,
+                        kind = "partial_hash",
+                    )
+                }
                 Some(GlobalAlloc::Static(..) | GlobalAlloc::Memory(..)) => {
                     err_ub_custom!(
                         fluent::const_eval_invalid_dealloc,
@@ -622,7 +629,9 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
             Some(GlobalAlloc::Function { .. }) => throw_ub!(DerefFunctionPointer(id)),
             Some(GlobalAlloc::VTable(..)) => throw_ub!(DerefVTablePointer(id)),
-            Some(GlobalAlloc::Type(..)) => throw_ub!(DerefTypeIdPointer(id)),
+            Some(GlobalAlloc::Type(..)) | Some(GlobalAlloc::PartialHash(..)) => {
+                throw_ub!(DerefTypeIdPointer(id))
+            }
             None => throw_ub!(PointerUseAfterFree(id, CheckInAllocMsg::MemoryAccess)),
             Some(GlobalAlloc::Static(def_id)) => {
                 assert!(self.tcx.is_static(def_id));
@@ -899,9 +908,10 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             let (size, align) = global_alloc.size_and_align(*self.tcx, self.typing_env);
             let mutbl = global_alloc.mutability(*self.tcx, self.typing_env);
             let kind = match global_alloc {
-                GlobalAlloc::Type(_) | GlobalAlloc::Static { .. } | GlobalAlloc::Memory { .. } => {
-                    AllocKind::LiveData
-                }
+                GlobalAlloc::Type(_)
+                | GlobalAlloc::PartialHash(_)
+                | GlobalAlloc::Static { .. }
+                | GlobalAlloc::Memory { .. } => AllocKind::LiveData,
                 GlobalAlloc::Function { .. } => bug!("We already checked function pointers above"),
                 GlobalAlloc::VTable { .. } => AllocKind::VTable,
             };
@@ -1214,6 +1224,9 @@ impl<'a, 'tcx, M: Machine<'tcx>> std::fmt::Debug for DumpAllocs<'a, 'tcx, M> {
                         Some(GlobalAlloc::Type(ty)) => {
                             write!(fmt, " (typeid for {ty})")?;
                         }
+                        Some(GlobalAlloc::PartialHash(ty)) => {
+                            write!(fmt, " (partial hash of {ty})")?;
+                        }
                         Some(GlobalAlloc::Static(did)) => {
                             write!(fmt, " (static: {})", self.ecx.tcx.def_path_str(did))?;
                         }

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -571,38 +571,43 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValidityVisitor<'rt, 'tcx, M> {
                     let (size, _align) =
                         global_alloc.size_and_align(*self.ecx.tcx, self.ecx.typing_env);
 
-                    if let GlobalAlloc::Static(did) = global_alloc {
-                        let DefKind::Static { nested, .. } = self.ecx.tcx.def_kind(did) else {
-                            bug!()
-                        };
-                        // Special handling for pointers to statics (irrespective of their type).
-                        assert!(!self.ecx.tcx.is_thread_local_static(did));
-                        assert!(self.ecx.tcx.is_static(did));
-                        // Mode-specific checks
-                        match ctfe_mode {
-                            CtfeValidationMode::Static { .. }
-                            | CtfeValidationMode::Promoted { .. } => {
-                                // We skip recursively checking other statics. These statics must be sound by
-                                // themselves, and the only way to get broken statics here is by using
-                                // unsafe code.
-                                // The reasons we don't check other statics is twofold. For one, in all
-                                // sound cases, the static was already validated on its own, and second, we
-                                // trigger cycle errors if we try to compute the value of the other static
-                                // and that static refers back to us (potentially through a promoted).
-                                // This could miss some UB, but that's fine.
-                                // We still walk nested allocations, as they are fundamentally part of this validation run.
-                                // This means we will also recurse into nested statics of *other*
-                                // statics, even though we do not recurse into other statics directly.
-                                // That's somewhat inconsistent but harmless.
-                                skip_recursive_check = !nested;
-                            }
-                            CtfeValidationMode::Const { .. } => {
-                                // We can't recursively validate `extern static`, so we better reject them.
-                                if self.ecx.tcx.is_foreign_item(did) {
-                                    throw_validation_failure!(self.path, ConstRefToExtern);
+                    match global_alloc {
+                        GlobalAlloc::Static(did) => {
+                            let DefKind::Static { nested, .. } = self.ecx.tcx.def_kind(did) else {
+                                bug!()
+                            };
+                            assert!(!self.ecx.tcx.is_thread_local_static(did));
+                            assert!(self.ecx.tcx.is_static(did));
+                            match ctfe_mode {
+                                CtfeValidationMode::Static { .. }
+                                | CtfeValidationMode::Promoted { .. } => {
+                                    // We skip recursively checking other statics. These statics must be sound by
+                                    // themselves, and the only way to get broken statics here is by using
+                                    // unsafe code.
+                                    // The reasons we don't check other statics is twofold. For one, in all
+                                    // sound cases, the static was already validated on its own, and second, we
+                                    // trigger cycle errors if we try to compute the value of the other static
+                                    // and that static refers back to us (potentially through a promoted).
+                                    // This could miss some UB, but that's fine.
+                                    // We still walk nested allocations, as they are fundamentally part of this validation run.
+                                    // This means we will also recurse into nested statics of *other*
+                                    // statics, even though we do not recurse into other statics directly.
+                                    // That's somewhat inconsistent but harmless.
+                                    skip_recursive_check = !nested;
+                                }
+                                CtfeValidationMode::Const { .. } => {
+                                    // We can't recursively validate `extern static`, so we better reject them.
+                                    if self.ecx.tcx.is_foreign_item(did) {
+                                        throw_validation_failure!(self.path, ConstRefToExtern);
+                                    }
                                 }
                             }
                         }
+                        // These are controlled by rustc and not available for CTFE
+                        GlobalAlloc::Type(_) | GlobalAlloc::PartialHash(_) => {
+                            skip_recursive_check = true
+                        }
+                        _ => (),
                     }
 
                     // If this allocation has size zero, there is no actual mutability here.

compiler/rustc_hir/src/lang_items.rs

@@ -274,6 +274,8 @@ language_item_table! {
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);
     CVoid,                   sym::c_void,              c_void,                     Target::Enum,           GenericRequirement::None;
 
+    TypeId,                  sym::type_id,             type_id,                    Target::Struct,         GenericRequirement::None;
+
     // A number of panic-related lang items. The `panic` item corresponds to divide-by-zero and
     // various panic cases with `match`. The `panic_bounds_check` item is for indexing arrays.
     //

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -220,7 +220,9 @@ pub(crate) fn check_intrinsic_type(
         sym::needs_drop => (1, 0, vec![], tcx.types.bool),
 
         sym::type_name => (1, 0, vec![], Ty::new_static_str(tcx)),
-        sym::type_id => (1, 0, vec![], tcx.types.u128),
+        sym::type_id => {
+            (1, 0, vec![], tcx.type_of(tcx.lang_items().type_id().unwrap()).instantiate_identity())
+        }
         sym::offset => (2, 0, vec![param(0), param(1)], param(0)),
         sym::arith_offset => (
             1,

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

@@ -104,6 +104,7 @@ enum AllocDiscriminant {
     VTable,
     Static,
     Type,
+    PartialHash,
 }
 
 pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<'tcx>>(
@@ -133,6 +134,11 @@ pub fn specialized_encode_alloc_id<'tcx, E: TyEncoder<'tcx>>(
             AllocDiscriminant::Type.encode(encoder);
             ty.encode(encoder);
         }
+        GlobalAlloc::PartialHash(ty) => {
+            trace!("encoding {alloc_id:?} with {ty:#?}");
+            AllocDiscriminant::PartialHash.encode(encoder);
+            ty.encode(encoder);
+        }
         GlobalAlloc::Static(did) => {
             assert!(!tcx.is_thread_local_static(did));
             // References to statics doesn't need to know about their allocations,
@@ -240,6 +246,12 @@ impl<'s> AllocDecodingSession<'s> {
                 trace!("decoded typid: {ty:?}");
                 decoder.interner().reserve_and_set_type_id_alloc(ty)
             }
+            AllocDiscriminant::PartialHash => {
+                trace!("creating typeid alloc ID");
+                let ty = Decodable::decode(decoder);
+                trace!("decoded typid: {ty:?}");
+                decoder.interner().reserve_and_set_type_id_partial_hash(ty)
+            }
             AllocDiscriminant::Static => {
                 trace!("creating extern static alloc ID");
                 let did = <DefId as Decodable<D>>::decode(decoder);
@@ -270,9 +282,10 @@ pub enum GlobalAlloc<'tcx> {
     Static(DefId),
     /// The alloc ID points to memory.
     Memory(ConstAllocation<'tcx>),
-    /// A TypeId pointer. For now cannot be turned into a runtime value.
-    /// TODO: turn into actual TypeId?
+    /// A pointer to be stored within a TypeId pointing to the full hash.
     Type(Ty<'tcx>),
+    /// A partial type hash (the first `size_of<usize>()` bytes of the hash).
+    PartialHash(Ty<'tcx>),
 }
 
 impl<'tcx> GlobalAlloc<'tcx> {
@@ -312,6 +325,7 @@ impl<'tcx> GlobalAlloc<'tcx> {
         match self {
             GlobalAlloc::Function { .. } => cx.data_layout().instruction_address_space,
             GlobalAlloc::Type(_)
+            | GlobalAlloc::PartialHash(_)
             | GlobalAlloc::Static(..)
             | GlobalAlloc::Memory(..)
             | GlobalAlloc::VTable(..) => AddressSpace::DATA,
@@ -350,7 +364,10 @@ impl<'tcx> GlobalAlloc<'tcx> {
                 }
             }
             GlobalAlloc::Memory(alloc) => alloc.inner().mutability,
-            GlobalAlloc::Type(_) | GlobalAlloc::Function { .. } | GlobalAlloc::VTable(..) => {
+            GlobalAlloc::PartialHash(_)
+            | GlobalAlloc::Type(_)
+            | GlobalAlloc::Function { .. }
+            | GlobalAlloc::VTable(..) => {
                 // These are immutable.
                 Mutability::Not
             }
@@ -398,8 +415,8 @@ impl<'tcx> GlobalAlloc<'tcx> {
                 // No data to be accessed here. But vtables are pointer-aligned.
                 (Size::ZERO, tcx.data_layout.pointer_align.abi)
             }
-            // TODO make this represent normal type ids somehow
-            GlobalAlloc::Type(_) => (Size::from_bytes(16), Align::from_bytes(8).unwrap()),
+            GlobalAlloc::Type(_) => (Size::from_bytes(16), Align::ONE),
+            GlobalAlloc::PartialHash(_) => (Size::ZERO, Align::ONE),
         }
     }
 }
@@ -505,11 +522,17 @@ impl<'tcx> TyCtxt<'tcx> {
         self.reserve_and_set_dedup(GlobalAlloc::VTable(ty, dyn_ty), salt)
     }
 
-    /// Generates an [AllocId] for a [core::mem::type_info::TypeId]. Will get deduplicated.
+    /// Generates an [AllocId] for a [core::mem::type_info::TypeIdData]. Will get deduplicated.
     pub fn reserve_and_set_type_id_alloc(self, ty: Ty<'tcx>) -> AllocId {
         self.reserve_and_set_dedup(GlobalAlloc::Type(ty), 0)
     }
 
+    /// Generates an [AllocId] that will get replaced by a partial hash of a type.
+    /// See [core::mem::type_info::TypeId] for more information.
+    pub fn reserve_and_set_type_id_partial_hash(self, ty: Ty<'tcx>) -> AllocId {
+        self.reserve_and_set_dedup(GlobalAlloc::PartialHash(ty), 0)
+    }
+
     /// Interns the `Allocation` and return a new `AllocId`, even if there's already an identical
     /// `Allocation` with a different `AllocId`.
     /// Statics with identical content will still point to the same `Allocation`, i.e.,

compiler/rustc_middle/src/mir/pretty.rs

@@ -1622,6 +1622,7 @@ pub fn write_allocations<'tcx>(
                 write!(w, " (vtable: impl {dyn_ty} for {ty})")?
             }
             Some(GlobalAlloc::Type(ty)) => write!(w, " (typeid for {ty})")?,
+            Some(GlobalAlloc::PartialHash(ty)) => write!(w, " (partial hash of {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)

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -1781,6 +1781,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
                         Some(GlobalAlloc::Function { .. }) => p!("<function>"),
                         Some(GlobalAlloc::VTable(..)) => p!("<vtable>"),
                         Some(GlobalAlloc::Type(_)) => p!("<typeid>"),
+                        Some(GlobalAlloc::PartialHash(_)) => p!("<hash>"),
                         None => p!("<dangling pointer>"),
                     }
                     return Ok(());

compiler/rustc_monomorphize/src/collector.rs

@@ -1228,6 +1228,7 @@ fn collect_alloc<'tcx>(tcx: TyCtxt<'tcx>, alloc_id: AllocId, output: &mut MonoIt
             collect_alloc(tcx, alloc_id, output)
         }
         GlobalAlloc::Type(_) => {}
+        GlobalAlloc::PartialHash(_) => {}
     }
 }