1 use rustc::ty::{self, Ty, TypeAndMut};
2 use rustc::ty::layout::{self, TyLayout, Size};
3 use rustc::ty::adjustment::{PointerCast};
4 use syntax::ast::{FloatTy, IntTy, UintTy};
5 use syntax::symbol::sym;
7 use rustc_apfloat::ieee::{Single, Double};
8 use rustc_apfloat::{Float, FloatConvert};
9 use rustc::mir::interpret::{
10 Scalar, InterpResult, Pointer, PointerArithmetic, InterpError,
12 use rustc::mir::CastKind;
14 use super::{InterpretCx, Machine, PlaceTy, OpTy, Immediate};
16 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> InterpretCx<'a, 'mir, 'tcx, M> {
17 fn type_is_fat_ptr(&self, ty: Ty<'tcx>) -> bool {
19 ty::RawPtr(ty::TypeAndMut { ty, .. }) |
20 ty::Ref(_, ty, _) => !self.type_is_sized(ty),
21 ty::Adt(def, _) if def.is_box() => !self.type_is_sized(ty.boxed_ty()),
28 src: OpTy<'tcx, M::PointerTag>,
30 dest: PlaceTy<'tcx, M::PointerTag>,
31 ) -> InterpResult<'tcx> {
32 use rustc::mir::CastKind::*;
34 Pointer(PointerCast::Unsize) => {
35 self.unsize_into(src, dest)?;
38 Misc | Pointer(PointerCast::MutToConstPointer) => {
39 let src = self.read_immediate(src)?;
41 if self.type_is_fat_ptr(src.layout.ty) {
42 match (*src, self.type_is_fat_ptr(dest.layout.ty)) {
43 // pointers to extern types
44 (Immediate::Scalar(_),_) |
45 // slices and trait objects to other slices/trait objects
46 (Immediate::ScalarPair(..), true) => {
47 // No change to immediate
48 self.write_immediate(*src, dest)?;
50 // slices and trait objects to thin pointers (dropping the metadata)
51 (Immediate::ScalarPair(data, _), false) => {
52 self.write_scalar(data, dest)?;
56 match src.layout.variants {
57 layout::Variants::Single { index } => {
59 src.layout.ty.discriminant_for_variant(*self.tcx, index)
61 // Cast from a univariant enum
62 assert!(src.layout.is_zst());
63 return self.write_scalar(
64 Scalar::from_uint(discr.val, dest.layout.size),
68 layout::Variants::Multiple { .. } => {},
71 let dest_val = self.cast_scalar(src.to_scalar()?, src.layout, dest.layout)?;
72 self.write_scalar(dest_val, dest)?;
76 Pointer(PointerCast::ReifyFnPointer) => {
77 // The src operand does not matter, just its type
78 match src.layout.ty.sty {
79 ty::FnDef(def_id, substs) => {
80 if self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
81 bug!("reifying a fn ptr that requires const arguments");
83 let instance: InterpResult<'tcx, _> = ty::Instance::resolve(
88 ).ok_or_else(|| InterpError::TooGeneric.into());
89 let fn_ptr = self.memory.create_fn_alloc(instance?);
90 self.write_scalar(Scalar::Ptr(fn_ptr.into()), dest)?;
92 _ => bug!("reify fn pointer on {:?}", src.layout.ty),
96 Pointer(PointerCast::UnsafeFnPointer) => {
97 let src = self.read_immediate(src)?;
98 match dest.layout.ty.sty {
100 // No change to value
101 self.write_immediate(*src, dest)?;
103 _ => bug!("fn to unsafe fn cast on {:?}", dest.layout.ty),
107 Pointer(PointerCast::ClosureFnPointer(_)) => {
108 // The src operand does not matter, just its type
109 match src.layout.ty.sty {
110 ty::Closure(def_id, substs) => {
111 let substs = self.subst_and_normalize_erasing_regions(substs)?;
112 let instance = ty::Instance::resolve_closure(
116 ty::ClosureKind::FnOnce,
118 let fn_ptr = self.memory.create_fn_alloc(instance);
119 let val = Immediate::Scalar(Scalar::Ptr(fn_ptr.into()).into());
120 self.write_immediate(val, dest)?;
122 _ => bug!("closure fn pointer on {:?}", src.layout.ty),
131 val: Scalar<M::PointerTag>,
132 src_layout: TyLayout<'tcx>,
133 dest_layout: TyLayout<'tcx>,
134 ) -> InterpResult<'tcx, Scalar<M::PointerTag>> {
135 use rustc::ty::TyKind::*;
136 trace!("Casting {:?}: {:?} to {:?}", val, src_layout.ty, dest_layout.ty);
138 match src_layout.ty.sty {
140 Float(FloatTy::F32) => self.cast_from_float(val.to_f32()?, dest_layout.ty),
141 Float(FloatTy::F64) => self.cast_from_float(val.to_f64()?, dest_layout.ty),
142 // Integer(-like), including fn ptr casts and casts from enums that
143 // are represented as integers (this excludes univariant enums, which
144 // are handled in `cast` directly).
147 src_layout.ty.is_bool() || src_layout.ty.is_char() ||
148 src_layout.ty.is_enum() || src_layout.ty.is_integral() ||
149 src_layout.ty.is_unsafe_ptr() || src_layout.ty.is_fn_ptr() ||
150 src_layout.ty.is_region_ptr(),
151 "Unexpected cast from type {:?}", src_layout.ty
153 match val.to_bits_or_ptr(src_layout.size, self) {
154 Err(ptr) => self.cast_from_ptr(ptr, dest_layout.ty),
155 Ok(data) => self.cast_from_int(data, src_layout, dest_layout),
164 src_layout: TyLayout<'tcx>,
165 dest_layout: TyLayout<'tcx>,
166 ) -> InterpResult<'tcx, Scalar<M::PointerTag>> {
167 // Let's make sure v is sign-extended *if* it has a signed type.
168 let signed = src_layout.abi.is_signed();
170 self.sign_extend(v, src_layout)
174 trace!("cast_from_int: {}, {}, {}", v, src_layout.ty, dest_layout.ty);
175 use rustc::ty::TyKind::*;
176 match dest_layout.ty.sty {
177 Int(_) | Uint(_) | RawPtr(_) => {
178 let v = self.truncate(v, dest_layout);
179 Ok(Scalar::from_uint(v, dest_layout.size))
182 Float(FloatTy::F32) if signed => Ok(Scalar::from_f32(
183 Single::from_i128(v as i128).value
185 Float(FloatTy::F64) if signed => Ok(Scalar::from_f64(
186 Double::from_i128(v as i128).value
188 Float(FloatTy::F32) => Ok(Scalar::from_f32(
189 Single::from_u128(v).value
191 Float(FloatTy::F64) => Ok(Scalar::from_f64(
192 Double::from_u128(v).value
196 // `u8` to `char` cast
197 debug_assert_eq!(v as u8 as u128, v);
198 Ok(Scalar::from_uint(v, Size::from_bytes(4)))
201 // Casts to bool are not permitted by rustc, no need to handle them here.
202 _ => err!(Unimplemented(format!("int to {:?} cast", dest_layout.ty))),
206 fn cast_from_float<F>(
210 ) -> InterpResult<'tcx, Scalar<M::PointerTag>>
211 where F: Float + Into<Scalar<M::PointerTag>> + FloatConvert<Single> + FloatConvert<Double>
213 use rustc::ty::TyKind::*;
217 let width = t.bit_width().unwrap_or_else(|| self.pointer_size().bits() as usize);
218 let v = f.to_u128(width).value;
219 // This should already fit the bit width
220 Ok(Scalar::from_uint(v, Size::from_bits(width as u64)))
224 let width = t.bit_width().unwrap_or_else(|| self.pointer_size().bits() as usize);
225 let v = f.to_i128(width).value;
226 Ok(Scalar::from_int(v, Size::from_bits(width as u64)))
229 Float(FloatTy::F32) =>
230 Ok(Scalar::from_f32(f.convert(&mut false).value)),
232 Float(FloatTy::F64) =>
233 Ok(Scalar::from_f64(f.convert(&mut false).value)),
235 _ => bug!("invalid float to {:?} cast", dest_ty),
241 ptr: Pointer<M::PointerTag>,
243 ) -> InterpResult<'tcx, Scalar<M::PointerTag>> {
244 use rustc::ty::TyKind::*;
246 // Casting to a reference or fn pointer is not permitted by rustc,
247 // no need to support it here.
250 Uint(UintTy::Usize) => Ok(ptr.into()),
251 Int(_) | Uint(_) => err!(ReadPointerAsBytes),
252 _ => err!(Unimplemented(format!("ptr to {:?} cast", ty))),
258 src: OpTy<'tcx, M::PointerTag>,
259 dest: PlaceTy<'tcx, M::PointerTag>,
263 ) -> InterpResult<'tcx> {
264 // A<Struct> -> A<Trait> conversion
265 let (src_pointee_ty, dest_pointee_ty) = self.tcx.struct_lockstep_tails(sty, dty);
267 match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
268 (&ty::Array(_, length), &ty::Slice(_)) => {
269 let ptr = self.read_immediate(src)?.to_scalar_ptr()?;
270 // u64 cast is from usize to u64, which is always good
271 let val = Immediate::new_slice(
273 length.unwrap_usize(self.tcx.tcx),
276 self.write_immediate(val, dest)
278 (&ty::Dynamic(..), &ty::Dynamic(..)) => {
279 // For now, upcasts are limited to changes in marker
280 // traits, and hence never actually require an actual
281 // change to the vtable.
282 let val = self.read_immediate(src)?;
283 self.write_immediate(*val, dest)
285 (_, &ty::Dynamic(ref data, _)) => {
286 // Initial cast from sized to dyn trait
287 let vtable = self.get_vtable(src_pointee_ty, data.principal())?;
288 let ptr = self.read_immediate(src)?.to_scalar_ptr()?;
289 let val = Immediate::new_dyn_trait(ptr, vtable);
290 self.write_immediate(val, dest)
293 _ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, dest.layout.ty),
299 src: OpTy<'tcx, M::PointerTag>,
300 dest: PlaceTy<'tcx, M::PointerTag>,
301 ) -> InterpResult<'tcx> {
302 trace!("Unsizing {:?} into {:?}", src, dest);
303 match (&src.layout.ty.sty, &dest.layout.ty.sty) {
304 (&ty::Ref(_, s, _), &ty::Ref(_, d, _)) |
305 (&ty::Ref(_, s, _), &ty::RawPtr(TypeAndMut { ty: d, .. })) |
306 (&ty::RawPtr(TypeAndMut { ty: s, .. }),
307 &ty::RawPtr(TypeAndMut { ty: d, .. })) => {
308 self.unsize_into_ptr(src, dest, s, d)
310 (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
311 assert_eq!(def_a, def_b);
312 if def_a.is_box() || def_b.is_box() {
313 if !def_a.is_box() || !def_b.is_box() {
314 bug!("invalid unsizing between {:?} -> {:?}", src.layout, dest.layout);
316 return self.unsize_into_ptr(
319 src.layout.ty.boxed_ty(),
320 dest.layout.ty.boxed_ty(),
324 // unsizing of generic struct with pointer fields
325 // Example: `Arc<T>` -> `Arc<Trait>`
326 // here we need to increase the size of every &T thin ptr field to a fat ptr
327 for i in 0..src.layout.fields.count() {
328 let dst_field = self.place_field(dest, i as u64)?;
329 if dst_field.layout.is_zst() {
332 let src_field = self.operand_field(src, i as u64)?;
333 if src_field.layout.ty == dst_field.layout.ty {
334 self.copy_op(src_field, dst_field)?;
336 self.unsize_into(src_field, dst_field)?;
343 "unsize_into: invalid conversion: {:?} -> {:?}",