Split up TypeId into pointer sized fields for CTFE to use as opaque ids

Author: oli-obk

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -175,8 +175,13 @@ pub(crate) fn codegen_const_value<'tcx>(
                             fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
                         fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
                     }
-                    // TODO: generate pointer to allocation containing the actual type id hash u128 value
-                    GlobalAlloc::Type(_) => todo!(),
+                    GlobalAlloc::Type { ty, segment } => {
+                        let data_id =
+                            data_id_for_ty(fx.tcx, &mut fx.constants_cx, fx.module, ty, segment);
+                        let local_data_id =
+                            fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
+                        fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
+                    }
                     GlobalAlloc::Static(def_id) => {
                         assert!(fx.tcx.is_static(def_id));
                         let data_id = data_id_for_static(
@@ -242,6 +247,17 @@ pub(crate) fn data_id_for_alloc_id(
         .or_insert_with(|| module.declare_anonymous_data(mutability.is_mut(), false).unwrap())
 }
 
+pub(crate) fn data_id_for_ty<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    cx: &mut ConstantCx,
+    module: &mut dyn Module,
+    ty: Ty<'tcx>,
+    segment: u8,
+) -> DataId {
+    let alloc_id = tcx.reserve_and_set_type_id_alloc(ty, segment);
+    data_id_for_alloc_id(cx, module, alloc_id, Mutability::Not)
+}
+
 pub(crate) fn data_id_for_vtable<'tcx>(
     tcx: TyCtxt<'tcx>,
     cx: &mut ConstantCx,
@@ -362,7 +378,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
                     GlobalAlloc::Memory(alloc) => alloc,
                     GlobalAlloc::Function { .. }
                     | GlobalAlloc::Static(_)
-                    | GlobalAlloc::Type(_)
+                    | GlobalAlloc::Type { .. }
                     | GlobalAlloc::VTable(..) => {
                         unreachable!()
                     }
@@ -475,7 +491,7 @@ fn define_all_allocs(tcx: TyCtxt<'_>, module: &mut dyn Module, cx: &mut Constant
                         .map(|principal| tcx.instantiate_bound_regions_with_erased(principal)),
                 ),
                 // TODO
-                GlobalAlloc::Type(_ty) => todo!(),
+                GlobalAlloc::Type { .. } => todo!(),
                 GlobalAlloc::Static(def_id) => {
                     if tcx.codegen_fn_attrs(def_id).flags.contains(CodegenFnAttrFlags::THREAD_LOCAL)
                     {

compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs

@@ -812,7 +812,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             dest.write_cvalue(fx, val);
         }
 
-        sym::needs_drop | sym::type_id | sym::type_name | sym::variant_count => {
+        sym::needs_drop | sym::type_name | sym::variant_count => {
             intrinsic_args!(fx, args => (); intrinsic);
 
             let const_val = fx

compiler/rustc_codegen_gcc/src/common.rs

@@ -1,10 +1,10 @@
 use gccjit::{LValue, RValue, ToRValue, Type};
-use rustc_abi as abi;
-use rustc_abi::HasDataLayout;
 use rustc_abi::Primitive::Pointer;
+use rustc_abi::{self as abi, Align, HasDataLayout, Size};
 use rustc_codegen_ssa::traits::{
     BaseTypeCodegenMethods, ConstCodegenMethods, MiscCodegenMethods, StaticCodegenMethods,
 };
+use rustc_const_eval::interpret::{AllocInit, Allocation, alloc_range};
 use rustc_middle::mir::Mutability;
 use rustc_middle::mir::interpret::{ConstAllocation, GlobalAlloc, Scalar};
 use rustc_middle::ty::layout::LayoutOf;
@@ -303,8 +303,30 @@ impl<'gcc, 'tcx> ConstCodegenMethods for CodegenCx<'gcc, 'tcx> {
                         let init = self.const_data_from_alloc(alloc);
                         self.static_addr_of(init, alloc.inner().align, None)
                     }
-                    // TODO: generate pointer to allocation containing the actual type id hash u128 value
-                    GlobalAlloc::Type(_ty) => todo!(),
+                    GlobalAlloc::Type { ty: type_id_ty, segment } => {
+                        let type_id = self.tcx.type_id_hash(type_id_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 val = self.const_usize(data);
+                        return self.context.new_cast(None, val, ty);
+                    }
                     GlobalAlloc::Static(def_id) => {
                         assert!(self.tcx.is_static(def_id));
                         self.get_static(def_id).get_address(None)

compiler/rustc_codegen_gcc/src/lib.rs

@@ -41,6 +41,7 @@ extern crate rustc_apfloat;
 extern crate rustc_ast;
 extern crate rustc_attr_data_structures;
 extern crate rustc_codegen_ssa;
+extern crate rustc_const_eval;
 extern crate rustc_data_structures;
 extern crate rustc_errors;
 extern crate rustc_fluent_macro;

compiler/rustc_codegen_llvm/src/common.rs

@@ -4,7 +4,7 @@ use std::borrow::Borrow;
 
 use libc::{c_char, c_uint};
 use rustc_abi::Primitive::Pointer;
-use rustc_abi::{self as abi, Align, HasDataLayout, Size};
+use rustc_abi::{self as abi, Align, HasDataLayout as _, Size};
 use rustc_ast::Mutability;
 use rustc_codegen_ssa::common::TypeKind;
 use rustc_codegen_ssa::traits::*;
@@ -319,17 +319,16 @@ impl<'ll, 'tcx> ConstCodegenMethods for CodegenCx<'ll, 'tcx> {
                             )))
                             .unwrap_memory();
                         let init = const_alloc_to_llvm(self, alloc.inner(), /*static*/ false);
-                        let value = self.static_addr_of_impl(init, alloc.inner().align, None);
-                        value
+                        self.static_addr_of_impl(init, alloc.inner().align, None)
                     }
                     GlobalAlloc::Static(def_id) => {
                         assert!(self.tcx.is_static(def_id));
                         assert!(!self.tcx.is_thread_local_static(def_id));
                         self.get_static(def_id)
                     }
-                    GlobalAlloc::Type(ty) => {
+                    GlobalAlloc::Type { ty, segment } => {
                         let type_id = self.tcx.type_id_hash(ty).as_u128();
-                        let mut alloc = Allocation::new(
+                        let mut alloc: Allocation = Allocation::new(
                             Size::from_bytes(16),
                             Align::from_bytes(8).unwrap(),
                             AllocInit::Uninit,
@@ -342,17 +341,13 @@ 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);
+                        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);
                         return unsafe { llvm::LLVMConstIntToPtr(llval, llty) };
                     }
                 };

compiler/rustc_codegen_ssa/src/mir/intrinsic.rs

@@ -150,7 +150,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 }
                 value
             }
-            sym::needs_drop | sym::type_id | sym::type_name | sym::variant_count => {
+            sym::needs_drop | sym::type_name | sym::variant_count => {
                 let value = bx.tcx().const_eval_instance(bx.typing_env(), instance, span).unwrap();
                 OperandRef::from_const(bx, value, result.layout.ty).immediate_or_packed_pair(bx)
             }

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -185,7 +185,7 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
         offset: Size,
     ) -> Self {
         let alloc_align = alloc.inner().align;
-        assert!(alloc_align >= layout.align.abi);
+        assert!(alloc_align >= layout.align.abi, "{alloc_align:?} < {:?}", layout.align.abi);
 
         let read_scalar = |start, size, s: abi::Scalar, ty| {
             match alloc.0.read_scalar(

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -405,18 +405,34 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
             }
             sym::type_id_eq => {
                 let a = ecx.project_field(&args[0], FieldIdx::ZERO)?;
-                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(a) = ecx.tcx.global_alloc(a) else { bug!() };
                 let b = ecx.project_field(&args[1], FieldIdx::ZERO)?;
-                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(b) = ecx.tcx.global_alloc(b) else { bug!() };
-                ecx.write_scalar(Scalar::from_bool(a == b), dest)?;
+                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)?;
             }
             sym::const_allocate => {
                 let size = ecx.read_scalar(&args[0])?.to_target_usize(ecx)?;

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -8,7 +8,7 @@ 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::interpret::{AllocId, AllocInit, 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};
@@ -33,24 +33,17 @@ pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAll
 }
 
 pub(crate) fn alloc_type_id<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> AllocId {
-    let ptr_size = tcx.data_layout.pointer_size;
+    let size = Size::from_bytes(16);
     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();
+    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();
+    }
 
     alloc.mutability = Mutability::Not;
 

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -346,20 +346,13 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                         kind = "vtable",
                     )
                 }
-                Some(GlobalAlloc::Type(..)) => {
+                Some(GlobalAlloc::Type { .. }) => {
                     err_ub_custom!(
                         fluent::const_eval_invalid_dealloc,
                         alloc_id = alloc_id,
                         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,
@@ -629,9 +622,7 @@ 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(..)) | Some(GlobalAlloc::PartialHash(..)) => {
-                throw_ub!(DerefTypeIdPointer(id))
-            }
+            Some(GlobalAlloc::Type { .. }) => throw_ub!(DerefTypeIdPointer(id)),
             None => throw_ub!(PointerUseAfterFree(id, CheckInAllocMsg::MemoryAccess)),
             Some(GlobalAlloc::Static(def_id)) => {
                 assert!(self.tcx.is_static(def_id));
@@ -908,8 +899,7 @@ 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::PartialHash(_)
+                GlobalAlloc::Type { .. }
                 | GlobalAlloc::Static { .. }
                 | GlobalAlloc::Memory { .. } => AllocKind::LiveData,
                 GlobalAlloc::Function { .. } => bug!("We already checked function pointers above"),
@@ -1221,11 +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)) => {
-                            write!(fmt, " (typeid for {ty})")?;
-                        }
-                        Some(GlobalAlloc::PartialHash(ty)) => {
-                            write!(fmt, " (partial hash of {ty})")?;
+                        Some(GlobalAlloc::Type { ty, segment }) => {
+                            write!(fmt, " (typeid segment {segment } for {ty})")?;
                         }
                         Some(GlobalAlloc::Static(did)) => {
                             write!(fmt, " (static: {})", self.ecx.tcx.def_path_str(did))?;