1 // Copyright 2018 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
11 use rustc::ty::{self, Ty};
12 use rustc::ty::layout::{Size, Align, LayoutOf};
13 use rustc::mir::interpret::{Scalar, Pointer, EvalResult, PointerArithmetic};
15 use super::{EvalContext, Machine, MemoryKind};
17 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
18 /// Creates a dynamic vtable for the given type and vtable origin. This is used only for
21 /// The `trait_ref` encodes the erased self type. Hence if we are
22 /// making an object `Foo<Trait>` from a value of type `Foo<T>`, then
23 /// `trait_ref` would map `T:Trait`.
27 trait_ref: ty::PolyTraitRef<'tcx>,
28 ) -> EvalResult<'tcx, Pointer<M::PointerTag>> {
29 debug!("get_vtable(trait_ref={:?})", trait_ref);
31 if let Some(&vtable) = self.vtables.get(&(ty, trait_ref)) {
32 return Ok(Pointer::from(vtable).with_default_tag());
35 let layout = self.layout_of(trait_ref.self_ty())?;
36 assert!(!layout.is_unsized(), "can't create a vtable for an unsized type");
37 let size = layout.size.bytes();
38 let align = layout.align.abi();
40 let ptr_size = self.pointer_size();
41 let ptr_align = self.tcx.data_layout.pointer_align;
42 let methods = self.tcx.vtable_methods(trait_ref);
43 let vtable = self.memory.allocate(
44 ptr_size * (3 + methods.len() as u64),
49 let drop = ::monomorphize::resolve_drop_in_place(*self.tcx, ty);
50 let drop = self.memory.create_fn_alloc(drop);
51 self.memory.write_ptr_sized(vtable, ptr_align, Scalar::Ptr(drop).into())?;
53 let size_ptr = vtable.offset(ptr_size, &self)?;
54 self.memory.write_ptr_sized(size_ptr, ptr_align, Scalar::from_uint(size, ptr_size).into())?;
55 let align_ptr = vtable.offset(ptr_size * 2, &self)?;
56 self.memory.write_ptr_sized(align_ptr, ptr_align,
57 Scalar::from_uint(align, ptr_size).into())?;
59 for (i, method) in methods.iter().enumerate() {
60 if let Some((def_id, substs)) = *method {
61 let instance = self.resolve(def_id, substs)?;
62 let fn_ptr = self.memory.create_fn_alloc(instance);
63 let method_ptr = vtable.offset(ptr_size * (3 + i as u64), &self)?;
64 self.memory.write_ptr_sized(method_ptr, ptr_align, Scalar::Ptr(fn_ptr).into())?;
68 self.memory.mark_immutable(vtable.alloc_id)?;
69 assert!(self.vtables.insert((ty, trait_ref), vtable.alloc_id).is_none());
74 /// Return the drop fn instance as well as the actual dynamic type
75 pub fn read_drop_type_from_vtable(
77 vtable: Pointer<M::PointerTag>,
78 ) -> EvalResult<'tcx, (ty::Instance<'tcx>, ty::Ty<'tcx>)> {
79 // we don't care about the pointee type, we just want a pointer
80 let pointer_align = self.tcx.data_layout.pointer_align;
81 let drop_fn = self.memory.read_ptr_sized(vtable, pointer_align)?.to_ptr()?;
82 let drop_instance = self.memory.get_fn(drop_fn)?;
83 trace!("Found drop fn: {:?}", drop_instance);
84 let fn_sig = drop_instance.ty(*self.tcx).fn_sig(*self.tcx);
85 let fn_sig = self.tcx.normalize_erasing_late_bound_regions(self.param_env, &fn_sig);
86 // the drop function takes *mut T where T is the type being dropped, so get that
87 let ty = fn_sig.inputs()[0].builtin_deref(true).unwrap().ty;
88 Ok((drop_instance, ty))
91 pub fn read_size_and_align_from_vtable(
93 vtable: Pointer<M::PointerTag>,
94 ) -> EvalResult<'tcx, (Size, Align)> {
95 let pointer_size = self.pointer_size();
96 let pointer_align = self.tcx.data_layout.pointer_align;
97 let size = self.memory.read_ptr_sized(vtable.offset(pointer_size, self)?,pointer_align)?
98 .to_bits(pointer_size)? as u64;
99 let align = self.memory.read_ptr_sized(
100 vtable.offset(pointer_size * 2, self)?,
102 )?.to_bits(pointer_size)? as u64;
103 Ok((Size::from_bytes(size), Align::from_bytes(align, align).unwrap()))