src/vtable.rs

   1 //! See librustc_codegen_llvm/meth.rs for reference
   2
   3 use crate::prelude::*;
   4
   5 const DROP_FN_INDEX: usize = 0;
   6 const SIZE_INDEX: usize = 1;
   7 const ALIGN_INDEX: usize = 2;
   8
   9 pub fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
  10     let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
  11     fx.bcx.ins().load(
  12         pointer_ty(fx.tcx),
  13         MemFlags::new(),
  14         vtable,
  15         (DROP_FN_INDEX * usize_size) as i32,
  16     )
  17 }
  18
  19 pub fn size_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
  20     let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
  21     fx.bcx.ins().load(
  22         pointer_ty(fx.tcx),
  23         MemFlags::new(),
  24         vtable,
  25         (SIZE_INDEX * usize_size) as i32,
  26     )
  27 }
  28
  29 pub fn min_align_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
  30     let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
  31     fx.bcx.ins().load(
  32         pointer_ty(fx.tcx),
  33         MemFlags::new(),
  34         vtable,
  35         (ALIGN_INDEX * usize_size) as i32,
  36     )
  37 }
  38
  39 pub fn get_ptr_and_method_ref<'tcx>(
  40     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
  41     arg: CValue<'tcx>,
  42     idx: usize,
  43 ) -> (Value, Value) {
  44     let (ptr, vtable) = arg.load_scalar_pair(fx);
  45     let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes();
  46     let func_ref = fx.bcx.ins().load(
  47         pointer_ty(fx.tcx),
  48         MemFlags::new(),
  49         vtable,
  50         ((idx + 3) * usize_size as usize) as i32,
  51     );
  52     (ptr, func_ref)
  53 }
  54
  55 pub fn get_vtable<'tcx>(
  56     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
  57     ty: Ty<'tcx>,
  58     trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
  59 ) -> Value {
  60     let data_id = if let Some(data_id) = fx.caches.vtables.get(&(ty, trait_ref)) {
  61         *data_id
  62     } else {
  63         let data_id = build_vtable(fx, ty, trait_ref);
  64         fx.caches.vtables.insert((ty, trait_ref), data_id);
  65         data_id
  66     };
  67
  68     let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
  69     fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
  70 }
  71
  72 fn build_vtable<'tcx>(
  73     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
  74     ty: Ty<'tcx>,
  75     trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
  76 ) -> DataId {
  77     let tcx = fx.tcx;
  78     let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
  79
  80     let drop_in_place_fn =
  81         import_function(tcx, fx.module, Instance::resolve_drop_in_place(tcx, ty));
  82
  83     let mut components: Vec<_> = vec![Some(drop_in_place_fn), None, None];
  84
  85     let methods_root;
  86     let methods = if let Some(trait_ref) = trait_ref {
  87         methods_root = tcx.vtable_methods(trait_ref.with_self_ty(tcx, ty));
  88         methods_root.iter()
  89     } else {
  90         (&[]).iter()
  91     };
  92     let methods = methods.cloned().map(|opt_mth| {
  93         opt_mth.map_or(None, |(def_id, substs)| {
  94             Some(import_function(
  95                 tcx,
  96                 fx.module,
  97                 Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), def_id, substs).unwrap(),
  98             ))
  99         })
 100     });
 101     components.extend(methods);
 102
 103     let mut data_ctx = DataContext::new();
 104     let mut data = ::std::iter::repeat(0u8)
 105         .take(components.len() * usize_size)
 106         .collect::<Vec<u8>>()
 107         .into_boxed_slice();
 108
 109     let layout = tcx.layout_of(ParamEnv::reveal_all().and(ty)).unwrap();
 110     write_usize(fx.tcx, &mut data, SIZE_INDEX, layout.size.bytes());
 111     write_usize(fx.tcx, &mut data, ALIGN_INDEX, layout.align.abi.bytes());
 112     data_ctx.define(data);
 113
 114     for (i, component) in components.into_iter().enumerate() {
 115         if let Some(func_id) = component {
 116             let func_ref = fx.module.declare_func_in_data(func_id, &mut data_ctx);
 117             data_ctx.write_function_addr((i * usize_size) as u32, func_ref);
 118         }
 119     }
 120
 121     let data_id = fx
 122         .module
 123         .declare_data(
 124             &format!("vtable.{:?}.for.{:?}", trait_ref, ty),
 125             Linkage::Local,
 126             false,
 127             Some(
 128                 fx.tcx
 129                     .data_layout
 130                     .pointer_align
 131                     .pref
 132                     .bytes()
 133                     .try_into()
 134                     .unwrap(),
 135             ),
 136         )
 137         .unwrap();
 138
 139     match fx.module.define_data(data_id, &data_ctx) {
 140         Ok(()) | Err(cranelift_module::ModuleError::DuplicateDefinition(_)) => {}
 141         err => err.unwrap(),
 142     }
 143
 144     data_id
 145 }
 146
 147 fn write_usize(tcx: TyCtxt, buf: &mut [u8], idx: usize, num: u64) {
 148     use byteorder::{BigEndian, LittleEndian, WriteBytesExt};
 149
 150     let usize_size = tcx
 151         .layout_of(ParamEnv::reveal_all().and(tcx.types.usize))
 152         .unwrap()
 153         .size
 154         .bytes() as usize;
 155     let mut target = &mut buf[idx * usize_size..(idx + 1) * usize_size];
 156
 157     match tcx.data_layout.endian {
 158         layout::Endian::Little => target.write_uint::<LittleEndian>(num, usize_size),
 159         layout::Endian::Big => target.write_uint::<BigEndian>(num, usize_size),
 160     }
 161     .unwrap()
 162 }