1 use rustc::ty::{self, Ty, TypeAndMut};
2 use rustc::ty::layout::{self, TyLayout, Size};
3 use syntax::ast::{FloatTy, IntTy, UintTy};
5 use rustc_apfloat::ieee::{Single, Double};
6 use rustc::mir::interpret::{
7 Scalar, EvalResult, Pointer, PointerArithmetic, EvalErrorKind, truncate
9 use rustc::mir::CastKind;
10 use rustc_apfloat::Float;
12 use super::{EvalContext, Machine, PlaceTy, OpTy, ImmTy, Immediate};
14 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
15 fn type_is_fat_ptr(&self, ty: Ty<'tcx>) -> bool {
17 ty::RawPtr(ty::TypeAndMut { ty, .. }) |
18 ty::Ref(_, ty, _) => !self.type_is_sized(ty),
19 ty::Adt(def, _) if def.is_box() => !self.type_is_sized(ty.boxed_ty()),
26 src: OpTy<'tcx, M::PointerTag>,
28 dest: PlaceTy<'tcx, M::PointerTag>,
29 ) -> EvalResult<'tcx> {
30 use rustc::mir::CastKind::*;
33 self.unsize_into(src, dest)?;
37 let src = self.read_immediate(src)?;
39 if self.type_is_fat_ptr(src.layout.ty) {
40 match (*src, self.type_is_fat_ptr(dest.layout.ty)) {
41 // pointers to extern types
42 (Immediate::Scalar(_),_) |
43 // slices and trait objects to other slices/trait objects
44 (Immediate::ScalarPair(..), true) => {
45 // No change to immediate
46 self.write_immediate(*src, dest)?;
48 // slices and trait objects to thin pointers (dropping the metadata)
49 (Immediate::ScalarPair(data, _), false) => {
50 self.write_scalar(data, dest)?;
54 match src.layout.variants {
55 layout::Variants::Single { index } => {
56 if let Some(def) = src.layout.ty.ty_adt_def() {
57 // Cast from a univariant enum
58 assert!(src.layout.is_zst());
60 .discriminant_for_variant(*self.tcx, index)
62 return self.write_scalar(
63 Scalar::from_uint(discr_val, dest.layout.size),
67 layout::Variants::Tagged { .. } |
68 layout::Variants::NicheFilling { .. } => {},
71 let dest_val = self.cast_scalar(src.to_scalar()?, src.layout, dest.layout)?;
72 self.write_scalar(dest_val, dest)?;
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, "rustc_args_required_const") {
81 bug!("reifying a fn ptr that requires \
84 let instance: EvalResult<'tcx, _> = ty::Instance::resolve(
89 ).ok_or_else(|| EvalErrorKind::TooGeneric.into());
90 let fn_ptr = self.memory.create_fn_alloc(instance?).with_default_tag();
91 self.write_scalar(Scalar::Ptr(fn_ptr.into()), dest)?;
93 ref other => bug!("reify fn pointer on {:?}", other),
98 let src = self.read_immediate(src)?;
99 match dest.layout.ty.sty {
101 // No change to value
102 self.write_immediate(*src, dest)?;
104 ref other => bug!("fn to unsafe fn cast on {:?}", other),
108 ClosureFnPointer => {
109 // The src operand does not matter, just its type
110 match src.layout.ty.sty {
111 ty::Closure(def_id, substs) => {
112 let substs = self.subst_and_normalize_erasing_regions(substs)?;
113 let instance = ty::Instance::resolve_closure(
117 ty::ClosureKind::FnOnce,
119 let fn_ptr = self.memory.create_fn_alloc(instance).with_default_tag();
120 let val = Immediate::Scalar(Scalar::Ptr(fn_ptr.into()).into());
121 self.write_immediate(val, dest)?;
123 ref other => bug!("closure fn pointer on {:?}", other),
130 pub(super) fn cast_scalar(
132 val: Scalar<M::PointerTag>,
133 src_layout: TyLayout<'tcx>,
134 dest_layout: TyLayout<'tcx>,
135 ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
136 use rustc::ty::TyKind::*;
137 trace!("Casting {:?}: {:?} to {:?}", val, src_layout.ty, dest_layout.ty);
140 Scalar::Ptr(ptr) => self.cast_from_ptr(ptr, dest_layout.ty),
141 Scalar::Bits { bits, size } => {
142 debug_assert_eq!(size as u64, src_layout.size.bytes());
143 debug_assert_eq!(truncate(bits, Size::from_bytes(size.into())), bits,
144 "Unexpected value of size {} before casting", size);
146 let res = match src_layout.ty.sty {
147 Float(fty) => self.cast_from_float(bits, fty, dest_layout.ty)?,
148 _ => self.cast_from_int(bits, src_layout, dest_layout)?,
153 Scalar::Ptr(_) => bug!("Fabricated a ptr value from an int...?"),
154 Scalar::Bits { bits, size } => {
155 debug_assert_eq!(size as u64, dest_layout.size.bytes());
156 debug_assert_eq!(truncate(bits, Size::from_bytes(size.into())), bits,
157 "Unexpected value of size {} after casting", size);
169 src_layout: TyLayout<'tcx>,
170 dest_layout: TyLayout<'tcx>,
171 ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
172 let signed = src_layout.abi.is_signed();
174 self.sign_extend(v, src_layout)
178 trace!("cast_from_int: {}, {}, {}", v, src_layout.ty, dest_layout.ty);
179 use rustc::ty::TyKind::*;
180 match dest_layout.ty.sty {
181 Int(_) | Uint(_) => {
182 let v = self.truncate(v, dest_layout);
183 Ok(Scalar::from_uint(v, dest_layout.size))
186 Float(FloatTy::F32) if signed => Ok(Scalar::from_uint(
187 Single::from_i128(v as i128).value.to_bits(),
190 Float(FloatTy::F64) if signed => Ok(Scalar::from_uint(
191 Double::from_i128(v as i128).value.to_bits(),
194 Float(FloatTy::F32) => Ok(Scalar::from_uint(
195 Single::from_u128(v).value.to_bits(),
198 Float(FloatTy::F64) => Ok(Scalar::from_uint(
199 Double::from_u128(v).value.to_bits(),
204 // `u8` to `char` cast
205 debug_assert_eq!(v as u8 as u128, v);
206 Ok(Scalar::from_uint(v, Size::from_bytes(4)))
209 // No alignment check needed for raw pointers.
210 // But we have to truncate to target ptr size.
212 Ok(Scalar::from_uint(
213 self.truncate_to_ptr(v).0,
218 // Casts to bool are not permitted by rustc, no need to handle them here.
219 _ => err!(Unimplemented(format!("int to {:?} cast", dest_layout.ty))),
228 ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
229 use rustc::ty::TyKind::*;
230 use rustc_apfloat::FloatConvert;
234 let width = t.bit_width().unwrap_or_else(|| self.pointer_size().bits() as usize);
236 FloatTy::F32 => Single::from_bits(bits).to_u128(width).value,
237 FloatTy::F64 => Double::from_bits(bits).to_u128(width).value,
239 // This should already fit the bit width
240 Ok(Scalar::from_uint(v, Size::from_bits(width as u64)))
244 let width = t.bit_width().unwrap_or_else(|| self.pointer_size().bits() as usize);
246 FloatTy::F32 => Single::from_bits(bits).to_i128(width).value,
247 FloatTy::F64 => Double::from_bits(bits).to_i128(width).value,
249 Ok(Scalar::from_int(v, Size::from_bits(width as u64)))
252 Float(FloatTy::F32) if fty == FloatTy::F64 => {
253 Ok(Scalar::from_uint(
254 Single::to_bits(Double::from_bits(bits).convert(&mut false).value),
259 Float(FloatTy::F64) if fty == FloatTy::F32 => {
260 Ok(Scalar::from_uint(
261 Double::to_bits(Single::from_bits(bits).convert(&mut false).value),
266 Float(FloatTy:: F64) => Ok(Scalar::from_uint(bits, Size::from_bits(64))),
267 Float(FloatTy:: F32) => Ok(Scalar::from_uint(bits, Size::from_bits(32))),
268 _ => err!(Unimplemented(format!("float to {:?} cast", dest_ty))),
274 ptr: Pointer<M::PointerTag>,
276 ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
277 use rustc::ty::TyKind::*;
279 // Casting to a reference or fn pointer is not permitted by rustc,
280 // no need to support it here.
283 Uint(UintTy::Usize) => Ok(ptr.into()),
284 Int(_) | Uint(_) => err!(ReadPointerAsBytes),
285 _ => err!(Unimplemented(format!("ptr to {:?} cast", ty))),
291 src: OpTy<'tcx, M::PointerTag>,
292 dest: PlaceTy<'tcx, M::PointerTag>,
296 ) -> EvalResult<'tcx> {
297 // A<Struct> -> A<Trait> conversion
298 let (src_pointee_ty, dest_pointee_ty) = self.tcx.struct_lockstep_tails(sty, dty);
300 match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
301 (&ty::Array(_, length), &ty::Slice(_)) => {
302 let ptr = self.read_immediate(src)?.to_scalar_ptr()?;
303 // u64 cast is from usize to u64, which is always good
304 let val = Immediate::new_slice(
306 length.unwrap_usize(self.tcx.tcx),
309 self.write_immediate(val, dest)
311 (&ty::Dynamic(..), &ty::Dynamic(..)) => {
312 // For now, upcasts are limited to changes in marker
313 // traits, and hence never actually require an actual
314 // change to the vtable.
315 let val = self.read_immediate(src)?;
316 self.write_immediate(*val, dest)
318 (_, &ty::Dynamic(ref data, _)) => {
319 // Initial cast from sized to dyn trait
320 let vtable = self.get_vtable(src_pointee_ty, data.principal())?;
321 let ptr = self.read_immediate(src)?.to_scalar_ptr()?;
322 let val = Immediate::new_dyn_trait(ptr, vtable);
323 self.write_immediate(val, dest)
326 _ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, dest.layout.ty),
332 src: OpTy<'tcx, M::PointerTag>,
333 dest: PlaceTy<'tcx, M::PointerTag>,
334 ) -> EvalResult<'tcx> {
335 match (&src.layout.ty.sty, &dest.layout.ty.sty) {
336 (&ty::Ref(_, s, _), &ty::Ref(_, d, _)) |
337 (&ty::Ref(_, s, _), &ty::RawPtr(TypeAndMut { ty: d, .. })) |
338 (&ty::RawPtr(TypeAndMut { ty: s, .. }),
339 &ty::RawPtr(TypeAndMut { ty: d, .. })) => {
340 self.unsize_into_ptr(src, dest, s, d)
342 (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
343 assert_eq!(def_a, def_b);
344 if def_a.is_box() || def_b.is_box() {
345 if !def_a.is_box() || !def_b.is_box() {
346 bug!("invalid unsizing between {:?} -> {:?}", src.layout, dest.layout);
348 return self.unsize_into_ptr(
351 src.layout.ty.boxed_ty(),
352 dest.layout.ty.boxed_ty(),
356 // unsizing of generic struct with pointer fields
357 // Example: `Arc<T>` -> `Arc<Trait>`
358 // here we need to increase the size of every &T thin ptr field to a fat ptr
359 for i in 0..src.layout.fields.count() {
360 let dst_field = self.place_field(dest, i as u64)?;
361 if dst_field.layout.is_zst() {
364 let src_field = match src.try_as_mplace() {
366 let src_field = self.mplace_field(mplace, i as u64)?;
370 let src_field_layout = src.layout.field(self, i)?;
371 // this must be a field covering the entire thing
372 assert_eq!(src.layout.fields.offset(i).bytes(), 0);
373 assert_eq!(src_field_layout.size, src.layout.size);
374 // just sawp out the layout
375 OpTy::from(ImmTy { imm: src.to_immediate(), layout: src_field_layout })
378 if src_field.layout.ty == dst_field.layout.ty {
379 self.copy_op(src_field, dst_field)?;
381 self.unsize_into(src_field, dst_field)?;
388 "unsize_into: invalid conversion: {:?} -> {:?}",