1 use std::convert::TryFrom;
3 use crate::mir::interpret::{alloc_range, AllocId, Allocation, Pointer, Scalar};
4 use crate::ty::fold::TypeFoldable;
5 use crate::ty::{self, DefId, SubstsRef, Ty, TyCtxt};
6 use rustc_ast::Mutability;
8 #[derive(Clone, Copy, Debug, PartialEq, HashStable)]
9 pub enum VtblEntry<'tcx> {
14 Method(DefId, SubstsRef<'tcx>),
17 pub const COMMON_VTABLE_ENTRIES: &[VtblEntry<'_>] =
18 &[VtblEntry::MetadataDropInPlace, VtblEntry::MetadataSize, VtblEntry::MetadataAlign];
20 pub const COMMON_VTABLE_ENTRIES_DROPINPLACE: usize = 0;
21 pub const COMMON_VTABLE_ENTRIES_SIZE: usize = 1;
22 pub const COMMON_VTABLE_ENTRIES_ALIGN: usize = 2;
24 impl<'tcx> TyCtxt<'tcx> {
25 /// Retrieves an allocation that represents the contents of a vtable.
26 /// There's a cache within `TyCtxt` so it will be deduplicated.
27 pub fn vtable_allocation(
30 poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
33 let vtables_cache = tcx.vtables_cache.lock();
34 if let Some(alloc_id) = vtables_cache.get(&(ty, poly_trait_ref)).cloned() {
39 // See https://github.com/rust-lang/rust/pull/86475#discussion_r655162674
41 !ty.needs_subst() && !poly_trait_ref.map_or(false, |trait_ref| trait_ref.needs_subst())
43 let param_env = ty::ParamEnv::reveal_all();
44 let vtable_entries = if let Some(poly_trait_ref) = poly_trait_ref {
45 let trait_ref = poly_trait_ref.with_self_ty(tcx, ty);
46 let trait_ref = tcx.erase_regions(trait_ref);
48 tcx.vtable_entries(trait_ref)
54 tcx.layout_of(param_env.and(ty)).expect("failed to build vtable representation");
55 assert!(!layout.is_unsized(), "can't create a vtable for an unsized type");
56 let size = layout.size.bytes();
57 let align = layout.align.abi.bytes();
59 let ptr_size = tcx.data_layout.pointer_size;
60 let ptr_align = tcx.data_layout.pointer_align.abi;
62 let vtable_size = ptr_size * u64::try_from(vtable_entries.len()).unwrap();
63 let mut vtable = Allocation::uninit(vtable_size, ptr_align);
65 // No need to do any alignment checks on the memory accesses below, because we know the
66 // allocation is correctly aligned as we created it above. Also we're only offsetting by
67 // multiples of `ptr_align`, which means that it will stay aligned to `ptr_align`.
69 for (idx, entry) in vtable_entries.iter().enumerate() {
70 let idx: u64 = u64::try_from(idx).unwrap();
71 let scalar = match entry {
72 VtblEntry::MetadataDropInPlace => {
73 let instance = ty::Instance::resolve_drop_in_place(tcx, ty);
74 let fn_alloc_id = tcx.create_fn_alloc(instance);
75 let fn_ptr = Pointer::from(fn_alloc_id);
78 VtblEntry::MetadataSize => Scalar::from_uint(size, ptr_size).into(),
79 VtblEntry::MetadataAlign => Scalar::from_uint(align, ptr_size).into(),
80 VtblEntry::Vacant => continue,
81 VtblEntry::Method(def_id, substs) => {
82 // See https://github.com/rust-lang/rust/pull/86475#discussion_r655162674
83 assert!(!substs.needs_subst());
85 // Prepare the fn ptr we write into the vtable.
87 ty::Instance::resolve_for_vtable(tcx, param_env, *def_id, substs)
88 .expect("resolution failed during building vtable representation")
90 let fn_alloc_id = tcx.create_fn_alloc(instance);
91 let fn_ptr = Pointer::from(fn_alloc_id);
96 .write_scalar(&tcx, alloc_range(ptr_size * idx, ptr_size), scalar)
97 .expect("failed to build vtable representation");
100 vtable.mutability = Mutability::Not;
101 let alloc_id = tcx.create_memory_alloc(tcx.intern_const_alloc(vtable));
102 let mut vtables_cache = self.vtables_cache.lock();
103 vtables_cache.insert((ty, poly_trait_ref), alloc_id);