compiler/rustc_middle/src/ty/vtable.rs

   1 use std::convert::TryFrom;
   2 use std::fmt;
   3
   4 use crate::mir::interpret::{alloc_range, AllocId, Allocation, Pointer, Scalar, ScalarMaybeUninit};
   5 use crate::ty::{self, Instance, PolyTraitRef, Ty, TyCtxt};
   6 use rustc_ast::Mutability;
   7
   8 #[derive(Clone, Copy, PartialEq, HashStable)]
   9 pub enum VtblEntry<'tcx> {
  10     MetadataDropInPlace,
  11     MetadataSize,
  12     MetadataAlign,
  13     Vacant,
  14     Method(Instance<'tcx>),
  15     TraitVPtr(PolyTraitRef<'tcx>),
  16 }
  17
  18 impl<'tcx> fmt::Debug for VtblEntry<'tcx> {
  19     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  20         // We want to call `Display` on `Instance` and `PolyTraitRef`,
  21         // so we implement this manually.
  22         match self {
  23             VtblEntry::MetadataDropInPlace => write!(f, "MetadataDropInPlace"),
  24             VtblEntry::MetadataSize => write!(f, "MetadataSize"),
  25             VtblEntry::MetadataAlign => write!(f, "MetadataAlign"),
  26             VtblEntry::Vacant => write!(f, "Vacant"),
  27             VtblEntry::Method(instance) => write!(f, "Method({})", instance),
  28             VtblEntry::TraitVPtr(trait_ref) => write!(f, "TraitVPtr({})", trait_ref),
  29         }
  30     }
  31 }
  32
  33 pub const COMMON_VTABLE_ENTRIES: &[VtblEntry<'_>] =
  34     &[VtblEntry::MetadataDropInPlace, VtblEntry::MetadataSize, VtblEntry::MetadataAlign];
  35
  36 pub const COMMON_VTABLE_ENTRIES_DROPINPLACE: usize = 0;
  37 pub const COMMON_VTABLE_ENTRIES_SIZE: usize = 1;
  38 pub const COMMON_VTABLE_ENTRIES_ALIGN: usize = 2;
  39
  40 impl<'tcx> TyCtxt<'tcx> {
  41     /// Retrieves an allocation that represents the contents of a vtable.
  42     /// There's a cache within `TyCtxt` so it will be deduplicated.
  43     pub fn vtable_allocation(
  44         self,
  45         ty: Ty<'tcx>,
  46         poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
  47     ) -> AllocId {
  48         let tcx = self;
  49         let vtables_cache = tcx.vtables_cache.lock();
  50         if let Some(alloc_id) = vtables_cache.get(&(ty, poly_trait_ref)).cloned() {
  51             return alloc_id;
  52         }
  53         drop(vtables_cache);
  54
  55         let vtable_entries = if let Some(poly_trait_ref) = poly_trait_ref {
  56             let trait_ref = poly_trait_ref.with_self_ty(tcx, ty);
  57             let trait_ref = tcx.erase_regions(trait_ref);
  58
  59             tcx.vtable_entries(trait_ref)
  60         } else {
  61             COMMON_VTABLE_ENTRIES
  62         };
  63
  64         let layout = tcx
  65             .layout_of(ty::ParamEnv::reveal_all().and(ty))
  66             .expect("failed to build vtable representation");
  67         assert!(!layout.is_unsized(), "can't create a vtable for an unsized type");
  68         let size = layout.size.bytes();
  69         let align = layout.align.abi.bytes();
  70
  71         let ptr_size = tcx.data_layout.pointer_size;
  72         let ptr_align = tcx.data_layout.pointer_align.abi;
  73
  74         let vtable_size = ptr_size * u64::try_from(vtable_entries.len()).unwrap();
  75         let mut vtable =
  76             Allocation::uninit(vtable_size, ptr_align, /* panic_on_fail */ true).unwrap();
  77
  78         // No need to do any alignment checks on the memory accesses below, because we know the
  79         // allocation is correctly aligned as we created it above. Also we're only offsetting by
  80         // multiples of `ptr_align`, which means that it will stay aligned to `ptr_align`.
  81
  82         for (idx, entry) in vtable_entries.iter().enumerate() {
  83             let idx: u64 = u64::try_from(idx).unwrap();
  84             let scalar = match entry {
  85                 VtblEntry::MetadataDropInPlace => {
  86                     let instance = ty::Instance::resolve_drop_in_place(tcx, ty);
  87                     let fn_alloc_id = tcx.create_fn_alloc(instance);
  88                     let fn_ptr = Pointer::from(fn_alloc_id);
  89                     ScalarMaybeUninit::from_pointer(fn_ptr, &tcx)
  90                 }
  91                 VtblEntry::MetadataSize => Scalar::from_uint(size, ptr_size).into(),
  92                 VtblEntry::MetadataAlign => Scalar::from_uint(align, ptr_size).into(),
  93                 VtblEntry::Vacant => continue,
  94                 VtblEntry::Method(instance) => {
  95                     // Prepare the fn ptr we write into the vtable.
  96                     let instance = instance.polymorphize(tcx);
  97                     let fn_alloc_id = tcx.create_fn_alloc(instance);
  98                     let fn_ptr = Pointer::from(fn_alloc_id);
  99                     ScalarMaybeUninit::from_pointer(fn_ptr, &tcx)
 100                 }
 101                 VtblEntry::TraitVPtr(trait_ref) => {
 102                     let super_trait_ref = trait_ref.map_bound(|trait_ref| {
 103                         ty::ExistentialTraitRef::erase_self_ty(tcx, trait_ref)
 104                     });
 105                     let supertrait_alloc_id = self.vtable_allocation(ty, Some(super_trait_ref));
 106                     let vptr = Pointer::from(supertrait_alloc_id);
 107                     ScalarMaybeUninit::from_pointer(vptr, &tcx)
 108                 }
 109             };
 110             vtable
 111                 .write_scalar(&tcx, alloc_range(ptr_size * idx, ptr_size), scalar)
 112                 .expect("failed to build vtable representation");
 113         }
 114
 115         vtable.mutability = Mutability::Not;
 116         let alloc_id = tcx.create_memory_alloc(tcx.intern_const_alloc(vtable));
 117         let mut vtables_cache = self.vtables_cache.lock();
 118         vtables_cache.insert((ty, poly_trait_ref), alloc_id);
 119         alloc_id
 120     }
 121 }