-//! See librustc_codegen_llvm/meth.rs for reference
+//! Codegen vtables and vtable accesses.
+//!
+//! See `rustc_codegen_ssa/src/meth.rs` for reference.
+use crate::constant::data_id_for_alloc_id;
use crate::prelude::*;
-const DROP_FN_INDEX: usize = 0;
-const SIZE_INDEX: usize = 1;
-const ALIGN_INDEX: usize = 2;
+pub(crate) 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
+}
-pub fn size_of_obj<'a, 'tcx: 'a>(
- fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
- val: CValue<'tcx>,
-) -> Value {
- let (_ptr, vtable) = val.load_value_pair(fx);
+pub(crate) fn drop_fn_of_obj(fx: &mut FunctionCx<'_, '_, '_>, vtable: Value) -> Value {
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
fx.bcx.ins().load(
- pointer_ty(fx.tcx),
- MemFlags::new(),
+ fx.pointer_type,
+ vtable_memflags(),
vtable,
- (SIZE_INDEX * usize_size) as i32,
+ (ty::COMMON_VTABLE_ENTRIES_DROPINPLACE * usize_size) as i32,
)
}
-pub fn min_align_of_obj<'a, 'tcx: 'a>(
- fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
- val: CValue<'tcx>,
-) -> Value {
- let (_ptr, vtable) = val.load_value_pair(fx);
+pub(crate) fn size_of_obj(fx: &mut FunctionCx<'_, '_, '_>, vtable: Value) -> Value {
+ let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
+ fx.bcx.ins().load(
+ fx.pointer_type,
+ vtable_memflags(),
+ vtable,
+ (ty::COMMON_VTABLE_ENTRIES_SIZE * usize_size) as i32,
+ )
+}
+
+pub(crate) fn min_align_of_obj(fx: &mut FunctionCx<'_, '_, '_>, vtable: Value) -> Value {
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
fx.bcx.ins().load(
- pointer_ty(fx.tcx),
- MemFlags::new(),
+ fx.pointer_type,
+ vtable_memflags(),
vtable,
- (ALIGN_INDEX * usize_size) as i32,
+ (ty::COMMON_VTABLE_ENTRIES_ALIGN * usize_size) as i32,
)
}
-pub fn get_ptr_and_method_ref<'a, 'tcx: 'a>(
- fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
+pub(crate) fn get_ptr_and_method_ref<'tcx>(
+ fx: &mut FunctionCx<'_, '_, 'tcx>,
arg: CValue<'tcx>,
idx: usize,
) -> (Value, Value) {
- let (ptr, vtable) = arg.load_value_pair(fx);
+ let (ptr, vtable) = if let Abi::ScalarPair(_, _) = arg.layout().abi {
+ arg.load_scalar_pair(fx)
+ } else {
+ let (ptr, vtable) = arg.try_to_ptr().unwrap();
+ (ptr.get_addr(fx), vtable.unwrap())
+ };
+
let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes();
let func_ref = fx.bcx.ins().load(
- pointer_ty(fx.tcx),
- MemFlags::new(),
+ fx.pointer_type,
+ vtable_memflags(),
vtable,
- ((idx + 3) * usize_size as usize) as i32,
+ (idx * usize_size as usize) as i32,
);
(ptr, func_ref)
}
-pub fn get_vtable<'a, 'tcx: 'a>(
- fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
+pub(crate) fn get_vtable<'tcx>(
+ fx: &mut FunctionCx<'_, '_, 'tcx>,
ty: Ty<'tcx>,
trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
) -> Value {
- let data_id = if let Some(data_id) = fx.caches.vtables.get(&(ty, trait_ref)) {
- *data_id
- } else {
- let data_id = build_vtable(fx, ty, trait_ref);
- fx.caches.vtables.insert((ty, trait_ref), data_id);
- data_id
- };
-
+ let alloc_id = fx.tcx.vtable_allocation((ty, trait_ref));
+ let data_id =
+ data_id_for_alloc_id(&mut fx.constants_cx, &mut *fx.module, alloc_id, Mutability::Not);
let local_data_id = fx.module.declare_data_in_func(data_id, &mut fx.bcx.func);
- fx.bcx
- .ins()
- .global_value(fx.module.pointer_type(), local_data_id)
-}
-
-fn build_vtable<'a, 'tcx: 'a>(
- fx: &mut FunctionCx<'a, 'tcx, impl Backend>,
- ty: Ty<'tcx>,
- trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
-) -> DataId {
- let tcx = fx.tcx;
- let usize_size = fx.layout_of(fx.tcx.types.usize).size.bytes() as usize;
-
- let (size, align) = tcx
- .layout_of(ParamEnv::reveal_all().and(ty))
- .unwrap()
- .size_and_align();
- let drop_in_place_fn =
- fx.get_function_id(crate::rustc_mir::monomorphize::resolve_drop_in_place(tcx, ty));
-
- let mut components: Vec<_> = vec![Some(drop_in_place_fn), None, None];
-
- if let Some(trait_ref) = trait_ref {
- let trait_ref = trait_ref.with_self_ty(tcx, ty);
- let methods = tcx.vtable_methods(trait_ref);
- let methods = methods.iter().cloned().map(|opt_mth| {
- opt_mth.map_or(None, |(def_id, substs)| {
- Some(fx.get_function_id(
- Instance::resolve(tcx, ParamEnv::reveal_all(), def_id, substs).unwrap(),
- ))
- })
- });
- components.extend(methods);
+ if fx.clif_comments.enabled() {
+ fx.add_comment(local_data_id, format!("vtable: {:?}", alloc_id));
}
-
- let mut data_ctx = DataContext::new();
- let mut data = ::std::iter::repeat(0u8)
- .take(components.len() * usize_size)
- .collect::<Vec<u8>>()
- .into_boxed_slice();
- write_usize(fx.tcx, &mut data, SIZE_INDEX, size.bytes());
- write_usize(fx.tcx, &mut data, ALIGN_INDEX, align.abi());
- 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(
- &format!("vtable.{:?}.for.{:?}", trait_ref, ty),
- Linkage::Local,
- false,
- ).unwrap();
- fx.module.define_data(data_id, &data_ctx).unwrap();
- 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),
- }.unwrap()
+ fx.bcx.ins().global_value(fx.pointer_type, local_data_id)
}
projects / rust.git / blobdiff