compiler/rustc_middle/src/ty/vtable.rs

   1 use std::convert::TryFrom;
   2
   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;
   7
   8 #[derive(Clone, Copy, Debug, PartialEq, HashStable)]
   9 pub enum VtblEntry<'tcx> {
  10     MetadataDropInPlace,
  11     MetadataSize,
  12     MetadataAlign,
  13     Vacant,
  14     Method(DefId, SubstsRef<'tcx>),
  15 }
  16
  17 pub const COMMON_VTABLE_ENTRIES: &[VtblEntry<'_>] =
  18     &[VtblEntry::MetadataDropInPlace, VtblEntry::MetadataSize, VtblEntry::MetadataAlign];
  19
  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;
  23
  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(
  28         self,
  29         ty: Ty<'tcx>,
  30         poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
  31     ) -> AllocId {
  32         let tcx = self;
  33         let vtables_cache = tcx.vtables_cache.lock();
  34         if let Some(alloc_id) = vtables_cache.get(&(ty, poly_trait_ref)).cloned() {
  35             return alloc_id;
  36         }
  37         drop(vtables_cache);
  38
  39         // See https://github.com/rust-lang/rust/pull/86475#discussion_r655162674
  40         assert!(
  41             !ty.needs_subst() && !poly_trait_ref.map_or(false, |trait_ref| trait_ref.needs_subst())
  42         );
  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);
  47
  48             tcx.vtable_entries(trait_ref)
  49         } else {
  50             COMMON_VTABLE_ENTRIES
  51         };
  52
  53         let layout =
  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();
  58
  59         let ptr_size = tcx.data_layout.pointer_size;
  60         let ptr_align = tcx.data_layout.pointer_align.abi;
  61
  62         let vtable_size = ptr_size * u64::try_from(vtable_entries.len()).unwrap();
  63         let mut vtable =
  64             Allocation::uninit(vtable_size, ptr_align, /* panic_on_fail */ true).unwrap();
  65
  66         // No need to do any alignment checks on the memory accesses below, because we know the
  67         // allocation is correctly aligned as we created it above. Also we're only offsetting by
  68         // multiples of `ptr_align`, which means that it will stay aligned to `ptr_align`.
  69
  70         for (idx, entry) in vtable_entries.iter().enumerate() {
  71             let idx: u64 = u64::try_from(idx).unwrap();
  72             let scalar = match entry {
  73                 VtblEntry::MetadataDropInPlace => {
  74                     let instance = ty::Instance::resolve_drop_in_place(tcx, ty);
  75                     let fn_alloc_id = tcx.create_fn_alloc(instance);
  76                     let fn_ptr = Pointer::from(fn_alloc_id);
  77                     fn_ptr.into()
  78                 }
  79                 VtblEntry::MetadataSize => Scalar::from_uint(size, ptr_size).into(),
  80                 VtblEntry::MetadataAlign => Scalar::from_uint(align, ptr_size).into(),
  81                 VtblEntry::Vacant => continue,
  82                 VtblEntry::Method(def_id, substs) => {
  83                     // See https://github.com/rust-lang/rust/pull/86475#discussion_r655162674
  84                     assert!(!substs.needs_subst());
  85
  86                     // Prepare the fn ptr we write into the vtable.
  87                     let instance =
  88                         ty::Instance::resolve_for_vtable(tcx, param_env, *def_id, substs)
  89                             .expect("resolution failed during building vtable representation")
  90                             .polymorphize(tcx);
  91                     let fn_alloc_id = tcx.create_fn_alloc(instance);
  92                     let fn_ptr = Pointer::from(fn_alloc_id);
  93                     fn_ptr.into()
  94                 }
  95             };
  96             vtable
  97                 .write_scalar(&tcx, alloc_range(ptr_size * idx, ptr_size), scalar)
  98                 .expect("failed to build vtable representation");
  99         }
 100
 101         vtable.mutability = Mutability::Not;
 102         let alloc_id = tcx.create_memory_alloc(tcx.intern_const_alloc(vtable));
 103         let mut vtables_cache = self.vtables_cache.lock();
 104         vtables_cache.insert((ty, poly_trait_ref), alloc_id);
 105         alloc_id
 106     }
 107 }