compiler/rustc_mir/src/interpret/cast.rs - third_party/rust - Git at Google

 use std::convert::TryFrom;

 use rustc_apfloat::ieee::{Double, Single};
 use rustc_apfloat::{Float, FloatConvert};
 use rustc_ast::FloatTy;
 use rustc_attr as attr;
 use rustc_middle::mir::interpret::{InterpResult, PointerArithmetic, Scalar};
 use rustc_middle::mir::CastKind;
 use rustc_middle::ty::adjustment::PointerCast;
 use rustc_middle::ty::layout::{IntegerExt, TyAndLayout};
 use rustc_middle::ty::{self, Ty, TypeAndMut};
 use rustc_span::symbol::sym;
 use rustc_target::abi::{Integer, LayoutOf, Variants};

 use super::{
     truncate, util::ensure_monomorphic_enough, FnVal, ImmTy, Immediate, InterpCx, Machine, OpTy,
     PlaceTy,
 };

 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     pub fn cast(
         &mut self,
         src: OpTy<'tcx, M::PointerTag>,
         cast_kind: CastKind,
         cast_ty: Ty<'tcx>,
         dest: PlaceTy<'tcx, M::PointerTag>,
     ) -> InterpResult<'tcx> {
         use rustc_middle::mir::CastKind::*;
         // FIXME: In which cases should we trigger UB when the source is uninit?
         match cast_kind {
             Pointer(PointerCast::Unsize) => {
                 let cast_ty = self.layout_of(cast_ty)?;
                 self.unsize_into(src, cast_ty, dest)?;
             }

             Misc => {
                 let src = self.read_immediate(src)?;
                 let res = self.misc_cast(src, cast_ty)?;
                 self.write_immediate(res, dest)?;
             }

             Pointer(PointerCast::MutToConstPointer | PointerCast::ArrayToPointer) => {
                 // These are NOPs, but can be wide pointers.
                 let v = self.read_immediate(src)?;
                 self.write_immediate(*v, dest)?;
             }

             Pointer(PointerCast::ReifyFnPointer) => {
                 // The src operand does not matter, just its type
                 match *src.layout.ty.kind() {
                     ty::FnDef(def_id, substs) => {
                         // All reifications must be monomorphic, bail out otherwise.
                         ensure_monomorphic_enough(*self.tcx, src.layout.ty)?;

                         if self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
                             span_bug!(
                                 self.cur_span(),
                                 "reifying a fn ptr that requires const arguments"
                             );
                         }

                         let instance = ty::Instance::resolve_for_fn_ptr(
                             *self.tcx,
                             self.param_env,
                             def_id,
                             substs,
                         )
                         .ok_or_else(|| err_inval!(TooGeneric))?;

                         let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
                         self.write_scalar(fn_ptr, dest)?;
                     }
                     _ => span_bug!(self.cur_span(), "reify fn pointer on {:?}", src.layout.ty),
                 }
             }

             Pointer(PointerCast::UnsafeFnPointer) => {
                 let src = self.read_immediate(src)?;
                 match cast_ty.kind() {
                     ty::FnPtr(_) => {
                         // No change to value
                         self.write_immediate(*src, dest)?;
                     }
                     _ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty),
                 }
             }

             Pointer(PointerCast::ClosureFnPointer(_)) => {
                 // The src operand does not matter, just its type
                 match *src.layout.ty.kind() {
                     ty::Closure(def_id, substs) => {
                         // All reifications must be monomorphic, bail out otherwise.
                         ensure_monomorphic_enough(*self.tcx, src.layout.ty)?;

                         let instance = ty::Instance::resolve_closure(
                             *self.tcx,
                             def_id,
                             substs,
                             ty::ClosureKind::FnOnce,
                         );
                         let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
                         self.write_scalar(fn_ptr, dest)?;
                     }
                     _ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),
                 }
             }
         }
         Ok(())
     }

     fn misc_cast(
         &self,
         src: ImmTy<'tcx, M::PointerTag>,
         cast_ty: Ty<'tcx>,
     ) -> InterpResult<'tcx, Immediate<M::PointerTag>> {
         use rustc_middle::ty::TyKind::*;
         trace!("Casting {:?}: {:?} to {:?}", *src, src.layout.ty, cast_ty);

         match src.layout.ty.kind() {
             // Floating point
             Float(FloatTy::F32) => {
                 return Ok(self.cast_from_float(src.to_scalar()?.to_f32()?, cast_ty).into());
             }
             Float(FloatTy::F64) => {
                 return Ok(self.cast_from_float(src.to_scalar()?.to_f64()?, cast_ty).into());
             }
             // The rest is integer/pointer-"like", including fn ptr casts and casts from enums that
             // are represented as integers.
             _ => assert!(
                 src.layout.ty.is_bool()
                     || src.layout.ty.is_char()
                     || src.layout.ty.is_enum()
                     || src.layout.ty.is_integral()
                     || src.layout.ty.is_any_ptr(),
                 "Unexpected cast from type {:?}",
                 src.layout.ty
             ),
         }

         // # First handle non-scalar source values.

         // Handle cast from a univariant (ZST) enum.
         match src.layout.variants {
             Variants::Single { index } => {
                 if let Some(discr) = src.layout.ty.discriminant_for_variant(*self.tcx, index) {
                     assert!(src.layout.is_zst());
                     let discr_layout = self.layout_of(discr.ty)?;
                     return Ok(self.cast_from_scalar(discr.val, discr_layout, cast_ty).into());
                 }
             }
             Variants::Multiple { .. } => {}
         }

         // Handle casting any ptr to raw ptr (might be a fat ptr).
         if src.layout.ty.is_any_ptr() && cast_ty.is_unsafe_ptr() {
             let dest_layout = self.layout_of(cast_ty)?;
             if dest_layout.size == src.layout.size {
                 // Thin or fat pointer that just hast the ptr kind of target type changed.
                 return Ok(*src);
             } else {
                 // Casting the metadata away from a fat ptr.
                 assert_eq!(src.layout.size, 2 * self.memory.pointer_size());
                 assert_eq!(dest_layout.size, self.memory.pointer_size());
                 assert!(src.layout.ty.is_unsafe_ptr());
                 return match *src {
                     Immediate::ScalarPair(data, _) => Ok(data.into()),
                     Immediate::Scalar(..) => span_bug!(
                         self.cur_span(),
                         "{:?} input to a fat-to-thin cast ({:?} -> {:?})",
                         *src,
                         src.layout.ty,
                         cast_ty
                     ),
                 };
             }
         }

         // # The remaining source values are scalar.

         // For all remaining casts, we either
         // (a) cast a raw ptr to usize, or
         // (b) cast from an integer-like (including bool, char, enums).
         // In both cases we want the bits.
         let bits = self.force_bits(src.to_scalar()?, src.layout.size)?;
         Ok(self.cast_from_scalar(bits, src.layout, cast_ty).into())
     }

     pub(super) fn cast_from_scalar(
         &self,
         v: u128, // raw bits (there is no ScalarTy so we separate data+layout)
         src_layout: TyAndLayout<'tcx>,
         cast_ty: Ty<'tcx>,
     ) -> Scalar<M::PointerTag> {
         // Let's make sure v is sign-extended *if* it has a signed type.
         let signed = src_layout.abi.is_signed(); // Also asserts that abi is `Scalar`.
         let v = if signed { self.sign_extend(v, src_layout) } else { v };
         trace!("cast_from_scalar: {}, {} -> {}", v, src_layout.ty, cast_ty);
         use rustc_middle::ty::TyKind::*;
         match *cast_ty.kind() {
             Int(_) | Uint(_) | RawPtr(_) => {
                 let size = match *cast_ty.kind() {
                     Int(t) => Integer::from_attr(self, attr::IntType::SignedInt(t)).size(),
                     Uint(t) => Integer::from_attr(self, attr::IntType::UnsignedInt(t)).size(),
                     RawPtr(_) => self.pointer_size(),
                     _ => bug!(),
                 };
                 let v = truncate(v, size);
                 Scalar::from_uint(v, size)
             }

             Float(FloatTy::F32) if signed => Scalar::from_f32(Single::from_i128(v as i128).value),
             Float(FloatTy::F64) if signed => Scalar::from_f64(Double::from_i128(v as i128).value),
             Float(FloatTy::F32) => Scalar::from_f32(Single::from_u128(v).value),
             Float(FloatTy::F64) => Scalar::from_f64(Double::from_u128(v).value),

             Char => {
                 // `u8` to `char` cast
                 Scalar::from_u32(u8::try_from(v).unwrap().into())
             }

             // Casts to bool are not permitted by rustc, no need to handle them here.
             _ => span_bug!(self.cur_span(), "invalid int to {:?} cast", cast_ty),
         }
     }

     fn cast_from_float<F>(&self, f: F, dest_ty: Ty<'tcx>) -> Scalar<M::PointerTag>
     where
         F: Float + Into<Scalar<M::PointerTag>> + FloatConvert<Single> + FloatConvert<Double>,
     {
         use rustc_middle::ty::TyKind::*;
         match *dest_ty.kind() {
             // float -> uint
             Uint(t) => {
                 let size = Integer::from_attr(self, attr::IntType::UnsignedInt(t)).size();
                 // `to_u128` is a saturating cast, which is what we need
                 // (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
                 let v = f.to_u128(size.bits_usize()).value;
                 // This should already fit the bit width
                 Scalar::from_uint(v, size)
             }
             // float -> int
             Int(t) => {
                 let size = Integer::from_attr(self, attr::IntType::SignedInt(t)).size();
                 // `to_i128` is a saturating cast, which is what we need
                 // (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
                 let v = f.to_i128(size.bits_usize()).value;
                 Scalar::from_int(v, size)
             }
             // float -> f32
             Float(FloatTy::F32) => Scalar::from_f32(f.convert(&mut false).value),
             // float -> f64
             Float(FloatTy::F64) => Scalar::from_f64(f.convert(&mut false).value),
             // That's it.
             _ => span_bug!(self.cur_span(), "invalid float to {:?} cast", dest_ty),
         }
     }

     fn unsize_into_ptr(
         &mut self,
         src: OpTy<'tcx, M::PointerTag>,
         dest: PlaceTy<'tcx, M::PointerTag>,
         // The pointee types
         source_ty: Ty<'tcx>,
         cast_ty: Ty<'tcx>,
     ) -> InterpResult<'tcx> {
         // A<Struct> -> A<Trait> conversion
         let (src_pointee_ty, dest_pointee_ty) =
             self.tcx.struct_lockstep_tails_erasing_lifetimes(source_ty, cast_ty, self.param_env);

         match (&src_pointee_ty.kind(), &dest_pointee_ty.kind()) {
             (&ty::Array(_, length), &ty::Slice(_)) => {
                 let ptr = self.read_immediate(src)?.to_scalar()?;
                 // u64 cast is from usize to u64, which is always good
                 let val =
                     Immediate::new_slice(ptr, length.eval_usize(*self.tcx, self.param_env), self);
                 self.write_immediate(val, dest)
             }
             (&ty::Dynamic(..), &ty::Dynamic(..)) => {
                 // For now, upcasts are limited to changes in marker
                 // traits, and hence never actually require an actual
                 // change to the vtable.
                 let val = self.read_immediate(src)?;
                 self.write_immediate(*val, dest)
             }
             (_, &ty::Dynamic(ref data, _)) => {
                 // Initial cast from sized to dyn trait
                 let vtable = self.get_vtable(src_pointee_ty, data.principal())?;
                 let ptr = self.read_immediate(src)?.to_scalar()?;
                 let val = Immediate::new_dyn_trait(ptr, vtable);
                 self.write_immediate(val, dest)
             }

             _ => {
                 span_bug!(self.cur_span(), "invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty)
             }
         }
     }

     fn unsize_into(
         &mut self,
         src: OpTy<'tcx, M::PointerTag>,
         cast_ty: TyAndLayout<'tcx>,
         dest: PlaceTy<'tcx, M::PointerTag>,
     ) -> InterpResult<'tcx> {
         trace!("Unsizing {:?} of type {} into {:?}", *src, src.layout.ty, cast_ty.ty);
         match (&src.layout.ty.kind(), &cast_ty.ty.kind()) {
             (&ty::Ref(_, s, _), &ty::Ref(_, c, _) | &ty::RawPtr(TypeAndMut { ty: c, .. }))
             | (&ty::RawPtr(TypeAndMut { ty: s, .. }), &ty::RawPtr(TypeAndMut { ty: c, .. })) => {
                 self.unsize_into_ptr(src, dest, s, c)
             }
             (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
                 assert_eq!(def_a, def_b);
                 if def_a.is_box() || def_b.is_box() {
                     if !def_a.is_box() || !def_b.is_box() {
                         span_bug!(
                             self.cur_span(),
                             "invalid unsizing between {:?} -> {:?}",
                             src.layout.ty,
                             cast_ty.ty
                         );
                     }
                     return self.unsize_into_ptr(
                         src,
                         dest,
                         src.layout.ty.boxed_ty(),
                         cast_ty.ty.boxed_ty(),
                     );
                 }

                 // unsizing of generic struct with pointer fields
                 // Example: `Arc<T>` -> `Arc<Trait>`
                 // here we need to increase the size of every &T thin ptr field to a fat ptr
                 for i in 0..src.layout.fields.count() {
                     let cast_ty_field = cast_ty.field(self, i)?;
                     if cast_ty_field.is_zst() {
                         continue;
                     }
                     let src_field = self.operand_field(src, i)?;
                     let dst_field = self.place_field(dest, i)?;
                     if src_field.layout.ty == cast_ty_field.ty {
                         self.copy_op(src_field, dst_field)?;
                     } else {
                         self.unsize_into(src_field, cast_ty_field, dst_field)?;
                     }
                 }
                 Ok(())
             }
             _ => span_bug!(
                 self.cur_span(),
                 "unsize_into: invalid conversion: {:?} -> {:?}",
                 src.layout,
                 dest.layout
             ),
         }
     }
 }
	use std::convert::TryFrom;

	use rustc_apfloat::ieee::{Double, Single};
	use rustc_apfloat::{Float, FloatConvert};
	use rustc_ast::FloatTy;
	use rustc_attr as attr;
	use rustc_middle::mir::interpret::{InterpResult, PointerArithmetic, Scalar};
	use rustc_middle::mir::CastKind;
	use rustc_middle::ty::adjustment::PointerCast;
	use rustc_middle::ty::layout::{IntegerExt, TyAndLayout};
	use rustc_middle::ty::{self, Ty, TypeAndMut};
	use rustc_span::symbol::sym;
	use rustc_target::abi::{Integer, LayoutOf, Variants};

	use super::{
	truncate, util::ensure_monomorphic_enough, FnVal, ImmTy, Immediate, InterpCx, Machine, OpTy,
	PlaceTy,
	};

	impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
	pub fn cast(
	&mut self,
	src: OpTy<'tcx, M::PointerTag>,
	cast_kind: CastKind,
	cast_ty: Ty<'tcx>,
	dest: PlaceTy<'tcx, M::PointerTag>,
	) -> InterpResult<'tcx> {
	use rustc_middle::mir::CastKind::*;
	// FIXME: In which cases should we trigger UB when the source is uninit?
	match cast_kind {
	Pointer(PointerCast::Unsize) => {
	let cast_ty = self.layout_of(cast_ty)?;
	self.unsize_into(src, cast_ty, dest)?;
	}

	Misc => {
	let src = self.read_immediate(src)?;
	let res = self.misc_cast(src, cast_ty)?;
	self.write_immediate(res, dest)?;
	}

	Pointer(PointerCast::MutToConstPointer \| PointerCast::ArrayToPointer) => {
	// These are NOPs, but can be wide pointers.
	let v = self.read_immediate(src)?;
	self.write_immediate(*v, dest)?;
	}

	Pointer(PointerCast::ReifyFnPointer) => {
	// The src operand does not matter, just its type
	match *src.layout.ty.kind() {
	ty::FnDef(def_id, substs) => {
	// All reifications must be monomorphic, bail out otherwise.
	ensure_monomorphic_enough(*self.tcx, src.layout.ty)?;

	if self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
	span_bug!(
	self.cur_span(),
	"reifying a fn ptr that requires const arguments"
	);
	}

	let instance = ty::Instance::resolve_for_fn_ptr(
	*self.tcx,
	self.param_env,
	def_id,
	substs,
	)
	.ok_or_else(\|\| err_inval!(TooGeneric))?;

	let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
	self.write_scalar(fn_ptr, dest)?;
	}
	_ => span_bug!(self.cur_span(), "reify fn pointer on {:?}", src.layout.ty),
	}
	}

	Pointer(PointerCast::UnsafeFnPointer) => {
	let src = self.read_immediate(src)?;
	match cast_ty.kind() {
	ty::FnPtr(_) => {
	// No change to value
	self.write_immediate(*src, dest)?;
	}
	_ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty),
	}
	}

	Pointer(PointerCast::ClosureFnPointer(_)) => {
	// The src operand does not matter, just its type
	match *src.layout.ty.kind() {
	ty::Closure(def_id, substs) => {
	// All reifications must be monomorphic, bail out otherwise.
	ensure_monomorphic_enough(*self.tcx, src.layout.ty)?;

	let instance = ty::Instance::resolve_closure(
	*self.tcx,
	def_id,
	substs,
	ty::ClosureKind::FnOnce,
	);
	let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
	self.write_scalar(fn_ptr, dest)?;
	}
	_ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),
	}
	}
	}
	Ok(())
	}

	fn misc_cast(
	&self,
	src: ImmTy<'tcx, M::PointerTag>,
	cast_ty: Ty<'tcx>,
	) -> InterpResult<'tcx, Immediate<M::PointerTag>> {
	use rustc_middle::ty::TyKind::*;
	trace!("Casting {:?}: {:?} to {:?}", *src, src.layout.ty, cast_ty);

	match src.layout.ty.kind() {
	// Floating point
	Float(FloatTy::F32) => {
	return Ok(self.cast_from_float(src.to_scalar()?.to_f32()?, cast_ty).into());
	}
	Float(FloatTy::F64) => {
	return Ok(self.cast_from_float(src.to_scalar()?.to_f64()?, cast_ty).into());
	}
	// The rest is integer/pointer-"like", including fn ptr casts and casts from enums that
	// are represented as integers.
	_ => assert!(
	src.layout.ty.is_bool()
	\|\| src.layout.ty.is_char()
	\|\| src.layout.ty.is_enum()
	\|\| src.layout.ty.is_integral()
	\|\| src.layout.ty.is_any_ptr(),
	"Unexpected cast from type {:?}",
	src.layout.ty
	),
	}

	// # First handle non-scalar source values.

	// Handle cast from a univariant (ZST) enum.
	match src.layout.variants {
	Variants::Single { index } => {
	if let Some(discr) = src.layout.ty.discriminant_for_variant(*self.tcx, index) {
	assert!(src.layout.is_zst());
	let discr_layout = self.layout_of(discr.ty)?;
	return Ok(self.cast_from_scalar(discr.val, discr_layout, cast_ty).into());
	}
	}
	Variants::Multiple { .. } => {}
	}

	// Handle casting any ptr to raw ptr (might be a fat ptr).
	if src.layout.ty.is_any_ptr() && cast_ty.is_unsafe_ptr() {
	let dest_layout = self.layout_of(cast_ty)?;
	if dest_layout.size == src.layout.size {
	// Thin or fat pointer that just hast the ptr kind of target type changed.
	return Ok(*src);
	} else {
	// Casting the metadata away from a fat ptr.
	assert_eq!(src.layout.size, 2 * self.memory.pointer_size());
	assert_eq!(dest_layout.size, self.memory.pointer_size());
	assert!(src.layout.ty.is_unsafe_ptr());
	return match *src {
	Immediate::ScalarPair(data, _) => Ok(data.into()),
	Immediate::Scalar(..) => span_bug!(
	self.cur_span(),
	"{:?} input to a fat-to-thin cast ({:?} -> {:?})",
	*src,
	src.layout.ty,
	cast_ty
	),
	};
	}
	}

	// # The remaining source values are scalar.

	// For all remaining casts, we either
	// (a) cast a raw ptr to usize, or
	// (b) cast from an integer-like (including bool, char, enums).
	// In both cases we want the bits.
	let bits = self.force_bits(src.to_scalar()?, src.layout.size)?;
	Ok(self.cast_from_scalar(bits, src.layout, cast_ty).into())
	}

	pub(super) fn cast_from_scalar(
	&self,
	v: u128, // raw bits (there is no ScalarTy so we separate data+layout)
	src_layout: TyAndLayout<'tcx>,
	cast_ty: Ty<'tcx>,
	) -> Scalar<M::PointerTag> {
	// Let's make sure v is sign-extended if it has a signed type.
	let signed = src_layout.abi.is_signed(); // Also asserts that abi is `Scalar`.
	let v = if signed { self.sign_extend(v, src_layout) } else { v };
	trace!("cast_from_scalar: {}, {} -> {}", v, src_layout.ty, cast_ty);
	use rustc_middle::ty::TyKind::*;
	match *cast_ty.kind() {
	Int(_) \| Uint(_) \| RawPtr(_) => {
	let size = match *cast_ty.kind() {
	Int(t) => Integer::from_attr(self, attr::IntType::SignedInt(t)).size(),
	Uint(t) => Integer::from_attr(self, attr::IntType::UnsignedInt(t)).size(),
	RawPtr(_) => self.pointer_size(),
	_ => bug!(),
	};
	let v = truncate(v, size);
	Scalar::from_uint(v, size)
	}

	Float(FloatTy::F32) if signed => Scalar::from_f32(Single::from_i128(v as i128).value),
	Float(FloatTy::F64) if signed => Scalar::from_f64(Double::from_i128(v as i128).value),
	Float(FloatTy::F32) => Scalar::from_f32(Single::from_u128(v).value),
	Float(FloatTy::F64) => Scalar::from_f64(Double::from_u128(v).value),

	Char => {
	// `u8` to `char` cast
	Scalar::from_u32(u8::try_from(v).unwrap().into())
	}

	// Casts to bool are not permitted by rustc, no need to handle them here.
	_ => span_bug!(self.cur_span(), "invalid int to {:?} cast", cast_ty),
	}
	}

	fn cast_from_float<F>(&self, f: F, dest_ty: Ty<'tcx>) -> Scalar<M::PointerTag>
	where
	F: Float + Into<Scalar<M::PointerTag>> + FloatConvert<Single> + FloatConvert<Double>,
	{
	use rustc_middle::ty::TyKind::*;
	match *dest_ty.kind() {
	// float -> uint
	Uint(t) => {
	let size = Integer::from_attr(self, attr::IntType::UnsignedInt(t)).size();
	// `to_u128` is a saturating cast, which is what we need
	// (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
	let v = f.to_u128(size.bits_usize()).value;
	// This should already fit the bit width
	Scalar::from_uint(v, size)
	}
	// float -> int
	Int(t) => {
	let size = Integer::from_attr(self, attr::IntType::SignedInt(t)).size();
	// `to_i128` is a saturating cast, which is what we need
	// (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
	let v = f.to_i128(size.bits_usize()).value;
	Scalar::from_int(v, size)
	}
	// float -> f32
	Float(FloatTy::F32) => Scalar::from_f32(f.convert(&mut false).value),
	// float -> f64
	Float(FloatTy::F64) => Scalar::from_f64(f.convert(&mut false).value),
	// That's it.
	_ => span_bug!(self.cur_span(), "invalid float to {:?} cast", dest_ty),
	}
	}

	fn unsize_into_ptr(
	&mut self,
	src: OpTy<'tcx, M::PointerTag>,
	dest: PlaceTy<'tcx, M::PointerTag>,
	// The pointee types
	source_ty: Ty<'tcx>,
	cast_ty: Ty<'tcx>,
	) -> InterpResult<'tcx> {
	// A<Struct> -> A<Trait> conversion
	let (src_pointee_ty, dest_pointee_ty) =
	self.tcx.struct_lockstep_tails_erasing_lifetimes(source_ty, cast_ty, self.param_env);

	match (&src_pointee_ty.kind(), &dest_pointee_ty.kind()) {
	(&ty::Array(_, length), &ty::Slice(_)) => {
	let ptr = self.read_immediate(src)?.to_scalar()?;
	// u64 cast is from usize to u64, which is always good
	let val =
	Immediate::new_slice(ptr, length.eval_usize(*self.tcx, self.param_env), self);
	self.write_immediate(val, dest)
	}
	(&ty::Dynamic(..), &ty::Dynamic(..)) => {
	// For now, upcasts are limited to changes in marker
	// traits, and hence never actually require an actual
	// change to the vtable.
	let val = self.read_immediate(src)?;
	self.write_immediate(*val, dest)
	}
	(_, &ty::Dynamic(ref data, _)) => {
	// Initial cast from sized to dyn trait
	let vtable = self.get_vtable(src_pointee_ty, data.principal())?;
	let ptr = self.read_immediate(src)?.to_scalar()?;
	let val = Immediate::new_dyn_trait(ptr, vtable);
	self.write_immediate(val, dest)
	}

	_ => {
	span_bug!(self.cur_span(), "invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty)
	}
	}
	}

	fn unsize_into(
	&mut self,
	src: OpTy<'tcx, M::PointerTag>,
	cast_ty: TyAndLayout<'tcx>,
	dest: PlaceTy<'tcx, M::PointerTag>,
	) -> InterpResult<'tcx> {
	trace!("Unsizing {:?} of type {} into {:?}", *src, src.layout.ty, cast_ty.ty);
	match (&src.layout.ty.kind(), &cast_ty.ty.kind()) {
	(&ty::Ref(_, s, _), &ty::Ref(_, c, _) \| &ty::RawPtr(TypeAndMut { ty: c, .. }))
	\| (&ty::RawPtr(TypeAndMut { ty: s, .. }), &ty::RawPtr(TypeAndMut { ty: c, .. })) => {
	self.unsize_into_ptr(src, dest, s, c)
	}
	(&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
	assert_eq!(def_a, def_b);
	if def_a.is_box() \|\| def_b.is_box() {
	if !def_a.is_box() \|\| !def_b.is_box() {
	span_bug!(
	self.cur_span(),
	"invalid unsizing between {:?} -> {:?}",
	src.layout.ty,
	cast_ty.ty
	);
	}
	return self.unsize_into_ptr(
	src,
	dest,
	src.layout.ty.boxed_ty(),
	cast_ty.ty.boxed_ty(),
	);
	}

	// unsizing of generic struct with pointer fields
	// Example: `Arc<T>` -> `Arc<Trait>`
	// here we need to increase the size of every &T thin ptr field to a fat ptr
	for i in 0..src.layout.fields.count() {
	let cast_ty_field = cast_ty.field(self, i)?;
	if cast_ty_field.is_zst() {
	continue;
	}
	let src_field = self.operand_field(src, i)?;
	let dst_field = self.place_field(dest, i)?;
	if src_field.layout.ty == cast_ty_field.ty {
	self.copy_op(src_field, dst_field)?;
	} else {
	self.unsize_into(src_field, cast_ty_field, dst_field)?;
	}
	}
	Ok(())
	}
	_ => span_bug!(
	self.cur_span(),
	"unsize_into: invalid conversion: {:?} -> {:?}",
	src.layout,
	dest.layout
	),
	}
	}
	}