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