2018-09-08 11:00:06 -05:00
|
|
|
//! See librustc_codegen_llvm/meth.rs for reference
|
|
|
|
|
|
|
|
use crate::prelude::*;
|
|
|
|
|
|
|
|
const DROP_FN_INDEX: usize = 0;
|
|
|
|
const SIZE_INDEX: usize = 1;
|
|
|
|
const ALIGN_INDEX: usize = 2;
|
|
|
|
|
2019-12-20 09:16:28 -06:00
|
|
|
fn vtable_memflags() -> MemFlags {
|
|
|
|
let mut flags = MemFlags::trusted(); // A vtable access is always aligned and will never trap.
|
|
|
|
flags.set_readonly(); // A vtable is always read-only.
|
|
|
|
flags
|
|
|
|
}
|
|
|
|
|
2019-08-31 12:28:09 -05:00
|
|
|
pub fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
|
2019-02-07 13:45:15 -06:00
|
|
|
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
|
|
|
|
fx.bcx.ins().load(
|
|
|
|
pointer_ty(fx.tcx),
|
2019-12-20 09:16:28 -06:00
|
|
|
vtable_memflags(),
|
2019-02-07 13:45:15 -06:00
|
|
|
vtable,
|
|
|
|
(DROP_FN_INDEX * usize_size) as i32,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2019-08-31 12:28:09 -05:00
|
|
|
pub fn size_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
|
2018-09-08 11:00:06 -05:00
|
|
|
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
|
|
|
|
fx.bcx.ins().load(
|
|
|
|
pointer_ty(fx.tcx),
|
2019-12-20 09:16:28 -06:00
|
|
|
vtable_memflags(),
|
2018-09-08 11:00:06 -05:00
|
|
|
vtable,
|
|
|
|
(SIZE_INDEX * usize_size) as i32,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2019-08-31 12:28:09 -05:00
|
|
|
pub fn min_align_of_obj(fx: &mut FunctionCx<'_, '_, impl Backend>, vtable: Value) -> Value {
|
2018-09-15 04:14:27 -05:00
|
|
|
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
|
|
|
|
fx.bcx.ins().load(
|
|
|
|
pointer_ty(fx.tcx),
|
2019-12-20 09:16:28 -06:00
|
|
|
vtable_memflags(),
|
2018-09-15 04:14:27 -05:00
|
|
|
vtable,
|
|
|
|
(ALIGN_INDEX * usize_size) as i32,
|
|
|
|
)
|
|
|
|
}
|
|
|
|
|
2019-08-18 09:52:07 -05:00
|
|
|
pub fn get_ptr_and_method_ref<'tcx>(
|
|
|
|
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
|
2018-09-08 11:00:06 -05:00
|
|
|
arg: CValue<'tcx>,
|
|
|
|
idx: usize,
|
|
|
|
) -> (Value, Value) {
|
2019-03-02 14:09:28 -06:00
|
|
|
let (ptr, vtable) = arg.load_scalar_pair(fx);
|
2018-09-08 11:00:06 -05:00
|
|
|
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes();
|
|
|
|
let func_ref = fx.bcx.ins().load(
|
|
|
|
pointer_ty(fx.tcx),
|
2019-12-20 09:16:28 -06:00
|
|
|
vtable_memflags(),
|
2018-09-08 11:00:06 -05:00
|
|
|
vtable,
|
|
|
|
((idx + 3) * usize_size as usize) as i32,
|
|
|
|
);
|
|
|
|
(ptr, func_ref)
|
|
|
|
}
|
|
|
|
|
2019-08-18 09:52:07 -05:00
|
|
|
pub fn get_vtable<'tcx>(
|
|
|
|
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
|
2020-01-15 06:17:09 -06:00
|
|
|
layout: TyLayout<'tcx>,
|
2019-01-06 08:27:20 -06:00
|
|
|
trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
|
2018-09-08 11:00:06 -05:00
|
|
|
) -> Value {
|
2020-01-15 06:17:09 -06:00
|
|
|
let data_id = if let Some(data_id) = fx.vtables.get(&(layout.ty, trait_ref)) {
|
2018-09-08 11:00:06 -05:00
|
|
|
*data_id
|
|
|
|
} else {
|
2020-01-15 06:17:09 -06:00
|
|
|
let data_id = build_vtable(fx, layout, trait_ref);
|
|
|
|
fx.vtables.insert((layout.ty, trait_ref), data_id);
|
2018-09-08 11:00:06 -05:00
|
|
|
data_id
|
|
|
|
};
|
|
|
|
|
|
|
|
let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
|
2018-11-07 06:32:02 -06:00
|
|
|
fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
|
2018-09-08 11:00:06 -05:00
|
|
|
}
|
|
|
|
|
2019-08-18 09:52:07 -05:00
|
|
|
fn build_vtable<'tcx>(
|
|
|
|
fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
|
2020-01-15 06:17:09 -06:00
|
|
|
layout: TyLayout<'tcx>,
|
2019-01-06 08:27:20 -06:00
|
|
|
trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
|
2018-09-08 11:00:06 -05:00
|
|
|
) -> DataId {
|
|
|
|
let tcx = fx.tcx;
|
|
|
|
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
|
|
|
|
|
2019-08-31 12:28:09 -05:00
|
|
|
let drop_in_place_fn =
|
2020-01-15 06:17:09 -06:00
|
|
|
import_function(tcx, fx.module, Instance::resolve_drop_in_place(tcx, layout.ty));
|
2018-09-08 11:00:06 -05:00
|
|
|
|
|
|
|
let mut components: Vec<_> = vec![Some(drop_in_place_fn), None, None];
|
|
|
|
|
2019-01-06 08:27:20 -06:00
|
|
|
let methods_root;
|
|
|
|
let methods = if let Some(trait_ref) = trait_ref {
|
2020-01-15 06:17:09 -06:00
|
|
|
methods_root = tcx.vtable_methods(trait_ref.with_self_ty(tcx, layout.ty));
|
2019-01-06 08:27:20 -06:00
|
|
|
methods_root.iter()
|
|
|
|
} else {
|
|
|
|
(&[]).iter()
|
|
|
|
};
|
|
|
|
let methods = methods.cloned().map(|opt_mth| {
|
2018-10-16 07:16:37 -05:00
|
|
|
opt_mth.map_or(None, |(def_id, substs)| {
|
2019-01-02 05:20:32 -06:00
|
|
|
Some(import_function(
|
|
|
|
tcx,
|
|
|
|
fx.module,
|
2019-02-23 03:30:15 -06:00
|
|
|
Instance::resolve_for_vtable(tcx, ParamEnv::reveal_all(), def_id, substs).unwrap(),
|
2018-10-16 07:16:37 -05:00
|
|
|
))
|
|
|
|
})
|
|
|
|
});
|
|
|
|
components.extend(methods);
|
2018-09-08 11:00:06 -05:00
|
|
|
|
|
|
|
let mut data_ctx = DataContext::new();
|
|
|
|
let mut data = ::std::iter::repeat(0u8)
|
|
|
|
.take(components.len() * usize_size)
|
|
|
|
.collect::<Vec<u8>>()
|
|
|
|
.into_boxed_slice();
|
2018-11-24 04:23:49 -06:00
|
|
|
|
|
|
|
write_usize(fx.tcx, &mut data, SIZE_INDEX, layout.size.bytes());
|
|
|
|
write_usize(fx.tcx, &mut data, ALIGN_INDEX, layout.align.abi.bytes());
|
2018-09-08 11:00:06 -05:00
|
|
|
data_ctx.define(data);
|
|
|
|
|
|
|
|
for (i, component) in components.into_iter().enumerate() {
|
|
|
|
if let Some(func_id) = component {
|
|
|
|
let func_ref = fx.module.declare_func_in_data(func_id, &mut data_ctx);
|
|
|
|
data_ctx.write_function_addr((i * usize_size) as u32, func_ref);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let data_id = fx
|
|
|
|
.module
|
|
|
|
.declare_data(
|
2020-01-15 06:17:09 -06:00
|
|
|
&format!("vtable.{:?}.for.{:?}", trait_ref, layout.ty),
|
2018-09-08 11:00:06 -05:00
|
|
|
Linkage::Local,
|
|
|
|
false,
|
2019-10-27 10:55:35 -05:00
|
|
|
false,
|
2019-08-31 12:28:09 -05:00
|
|
|
Some(
|
|
|
|
fx.tcx
|
|
|
|
.data_layout
|
|
|
|
.pointer_align
|
|
|
|
.pref
|
|
|
|
.bytes()
|
|
|
|
.try_into()
|
|
|
|
.unwrap(),
|
|
|
|
),
|
2018-10-10 12:07:13 -05:00
|
|
|
)
|
|
|
|
.unwrap();
|
2019-04-27 11:49:13 -05:00
|
|
|
|
|
|
|
match fx.module.define_data(data_id, &data_ctx) {
|
|
|
|
Ok(()) | Err(cranelift_module::ModuleError::DuplicateDefinition(_)) => {}
|
|
|
|
err => err.unwrap(),
|
|
|
|
}
|
|
|
|
|
2018-09-08 11:00:06 -05:00
|
|
|
data_id
|
|
|
|
}
|
|
|
|
|
|
|
|
fn write_usize(tcx: TyCtxt, buf: &mut [u8], idx: usize, num: u64) {
|
|
|
|
use byteorder::{BigEndian, LittleEndian, WriteBytesExt};
|
|
|
|
|
|
|
|
let usize_size = tcx
|
|
|
|
.layout_of(ParamEnv::reveal_all().and(tcx.types.usize))
|
|
|
|
.unwrap()
|
|
|
|
.size
|
|
|
|
.bytes() as usize;
|
|
|
|
let mut target = &mut buf[idx * usize_size..(idx + 1) * usize_size];
|
|
|
|
|
|
|
|
match tcx.data_layout.endian {
|
|
|
|
layout::Endian::Little => target.write_uint::<LittleEndian>(num, usize_size),
|
|
|
|
layout::Endian::Big => target.write_uint::<BigEndian>(num, usize_size),
|
2018-10-10 12:07:13 -05:00
|
|
|
}
|
|
|
|
.unwrap()
|
2018-09-08 11:00:06 -05:00
|
|
|
}
|