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, TypeAndMut};
12 use rustc::ty::layout::{self, TyLayout, Size};
13 use syntax::ast::{FloatTy, IntTy, UintTy};
15 use rustc_apfloat::ieee::{Single, Double};
16 use rustc::mir::interpret::{
17 Scalar, EvalResult, Pointer, PointerArithmetic, EvalErrorKind, truncate
19 use rustc::mir::CastKind;
20 use rustc_apfloat::Float;
22 use super::{EvalContext, Machine, PlaceTy, OpTy, Value};
24 impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
25 fn type_is_fat_ptr(&self, ty: Ty<'tcx>) -> bool {
27 ty::RawPtr(ty::TypeAndMut { ty, .. }) |
28 ty::Ref(_, ty, _) => !self.type_is_sized(ty),
29 ty::Adt(def, _) if def.is_box() => !self.type_is_sized(ty.boxed_ty()),
36 src: OpTy<'tcx, M::PointerTag>,
38 dest: PlaceTy<'tcx, M::PointerTag>,
39 ) -> EvalResult<'tcx> {
40 let src_layout = src.layout;
41 let dst_layout = dest.layout;
42 use rustc::mir::CastKind::*;
45 self.unsize_into(src, dest)?;
49 let src = self.read_value(src)?;
50 if self.type_is_fat_ptr(src_layout.ty) {
51 match (*src, self.type_is_fat_ptr(dest.layout.ty)) {
52 // pointers to extern types
53 (Value::Scalar(_),_) |
54 // slices and trait objects to other slices/trait objects
55 (Value::ScalarPair(..), true) => {
57 self.write_value(*src, dest)?;
59 // slices and trait objects to thin pointers (dropping the metadata)
60 (Value::ScalarPair(data, _), false) => {
61 self.write_scalar(data, dest)?;
65 match src_layout.variants {
66 layout::Variants::Single { index } => {
67 if let Some(def) = src_layout.ty.ty_adt_def() {
69 .discriminant_for_variant(*self.tcx, index)
71 return self.write_scalar(
72 Scalar::from_uint(discr_val, dst_layout.size),
76 layout::Variants::Tagged { .. } |
77 layout::Variants::NicheFilling { .. } => {},
80 let src = src.to_scalar()?;
81 let dest_val = self.cast_scalar(src, src_layout, dest.layout)?;
82 self.write_scalar(dest_val, dest)?;
87 // The src operand does not matter, just its type
88 match src_layout.ty.sty {
89 ty::FnDef(def_id, substs) => {
90 if self.tcx.has_attr(def_id, "rustc_args_required_const") {
91 bug!("reifying a fn ptr that requires \
94 let instance: EvalResult<'tcx, _> = ty::Instance::resolve(
99 ).ok_or_else(|| EvalErrorKind::TooGeneric.into());
100 let fn_ptr = self.memory.create_fn_alloc(instance?);
101 self.write_scalar(Scalar::Ptr(fn_ptr.into()), dest)?;
103 ref other => bug!("reify fn pointer on {:?}", other),
108 let src = self.read_value(src)?;
109 match dest.layout.ty.sty {
111 // No change to value
112 self.write_value(*src, dest)?;
114 ref other => bug!("fn to unsafe fn cast on {:?}", other),
118 ClosureFnPointer => {
119 // The src operand does not matter, just its type
120 match src_layout.ty.sty {
121 ty::Closure(def_id, substs) => {
122 let substs = self.tcx.subst_and_normalize_erasing_regions(
124 ty::ParamEnv::reveal_all(),
127 let instance = ty::Instance::resolve_closure(
131 ty::ClosureKind::FnOnce,
133 let fn_ptr = self.memory.create_fn_alloc(instance);
134 let val = Value::Scalar(Scalar::Ptr(fn_ptr.into()).into());
135 self.write_value(val, dest)?;
137 ref other => bug!("closure fn pointer on {:?}", other),
144 pub(super) fn cast_scalar(
146 val: Scalar<M::PointerTag>,
147 src_layout: TyLayout<'tcx>,
148 dest_layout: TyLayout<'tcx>,
149 ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
150 use rustc::ty::TyKind::*;
151 trace!("Casting {:?}: {:?} to {:?}", val, src_layout.ty, dest_layout.ty);
154 Scalar::Ptr(ptr) => self.cast_from_ptr(ptr, dest_layout.ty),
155 Scalar::Bits { bits, size } => {
156 debug_assert_eq!(size as u64, src_layout.size.bytes());
157 debug_assert_eq!(truncate(bits, Size::from_bytes(size.into())), bits,
158 "Unexpected value of size {} before casting", size);
160 let res = match src_layout.ty.sty {
161 Float(fty) => self.cast_from_float(bits, fty, dest_layout.ty)?,
162 _ => self.cast_from_int(bits, src_layout, dest_layout)?,
167 Scalar::Ptr(_) => bug!("Fabricated a ptr value from an int...?"),
168 Scalar::Bits { bits, size } => {
169 debug_assert_eq!(size as u64, dest_layout.size.bytes());
170 debug_assert_eq!(truncate(bits, Size::from_bytes(size.into())), bits,
171 "Unexpected value of size {} after casting", size);
183 src_layout: TyLayout<'tcx>,
184 dest_layout: TyLayout<'tcx>,
185 ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
186 let signed = src_layout.abi.is_signed();
188 self.sign_extend(v, src_layout)
192 trace!("cast_from_int: {}, {}, {}", v, src_layout.ty, dest_layout.ty);
193 use rustc::ty::TyKind::*;
194 match dest_layout.ty.sty {
195 Int(_) | Uint(_) => {
196 let v = self.truncate(v, dest_layout);
197 Ok(Scalar::from_uint(v, dest_layout.size))
200 Float(FloatTy::F32) if signed => Ok(Scalar::from_uint(
201 Single::from_i128(v as i128).value.to_bits(),
204 Float(FloatTy::F64) if signed => Ok(Scalar::from_uint(
205 Double::from_i128(v as i128).value.to_bits(),
208 Float(FloatTy::F32) => Ok(Scalar::from_uint(
209 Single::from_u128(v).value.to_bits(),
212 Float(FloatTy::F64) => Ok(Scalar::from_uint(
213 Double::from_u128(v).value.to_bits(),
218 // `u8` to `char` cast
219 debug_assert_eq!(v as u8 as u128, v);
220 Ok(Scalar::from_uint(v, Size::from_bytes(4)))
223 // No alignment check needed for raw pointers.
224 // But we have to truncate to target ptr size.
226 Ok(Scalar::from_uint(
227 self.truncate_to_ptr(v).0,
232 // Casts to bool are not permitted by rustc, no need to handle them here.
233 _ => err!(Unimplemented(format!("int to {:?} cast", dest_layout.ty))),
242 ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
243 use rustc::ty::TyKind::*;
244 use rustc_apfloat::FloatConvert;
248 let width = t.bit_width().unwrap_or(self.pointer_size().bits() as usize);
250 FloatTy::F32 => Single::from_bits(bits).to_u128(width).value,
251 FloatTy::F64 => Double::from_bits(bits).to_u128(width).value,
253 // This should already fit the bit width
254 Ok(Scalar::from_uint(v, Size::from_bits(width as u64)))
258 let width = t.bit_width().unwrap_or(self.pointer_size().bits() as usize);
260 FloatTy::F32 => Single::from_bits(bits).to_i128(width).value,
261 FloatTy::F64 => Double::from_bits(bits).to_i128(width).value,
263 Ok(Scalar::from_int(v, Size::from_bits(width as u64)))
266 Float(FloatTy::F32) if fty == FloatTy::F64 => {
267 Ok(Scalar::from_uint(
268 Single::to_bits(Double::from_bits(bits).convert(&mut false).value),
273 Float(FloatTy::F64) if fty == FloatTy::F32 => {
274 Ok(Scalar::from_uint(
275 Double::to_bits(Single::from_bits(bits).convert(&mut false).value),
280 Float(FloatTy:: F64) => Ok(Scalar::from_uint(bits, Size::from_bits(64))),
281 Float(FloatTy:: F32) => Ok(Scalar::from_uint(bits, Size::from_bits(32))),
282 _ => err!(Unimplemented(format!("float to {:?} cast", dest_ty))),
288 ptr: Pointer<M::PointerTag>,
290 ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
291 use rustc::ty::TyKind::*;
293 // Casting to a reference or fn pointer is not permitted by rustc,
294 // no need to support it here.
297 Uint(UintTy::Usize) => Ok(ptr.into()),
298 Int(_) | Uint(_) => err!(ReadPointerAsBytes),
299 _ => err!(Unimplemented(format!("ptr to {:?} cast", ty))),
305 src: OpTy<'tcx, M::PointerTag>,
306 dest: PlaceTy<'tcx, M::PointerTag>,
310 ) -> EvalResult<'tcx> {
311 // A<Struct> -> A<Trait> conversion
312 let (src_pointee_ty, dest_pointee_ty) = self.tcx.struct_lockstep_tails(sty, dty);
314 match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
315 (&ty::Array(_, length), &ty::Slice(_)) => {
316 let ptr = self.read_value(src)?.to_scalar_ptr()?;
317 // u64 cast is from usize to u64, which is always good
318 let val = Value::new_slice(ptr, length.unwrap_usize(self.tcx.tcx), self.tcx.tcx);
319 self.write_value(val, dest)
321 (&ty::Dynamic(..), &ty::Dynamic(..)) => {
322 // For now, upcasts are limited to changes in marker
323 // traits, and hence never actually require an actual
324 // change to the vtable.
325 let val = self.read_value(src)?;
326 self.write_value(*val, dest)
328 (_, &ty::Dynamic(ref data, _)) => {
329 // Initial cast from sized to dyn trait
330 let vtable = self.get_vtable(src_pointee_ty, data.principal())?;
331 let ptr = self.read_value(src)?.to_scalar_ptr()?;
332 let val = Value::new_dyn_trait(ptr, vtable);
333 self.write_value(val, dest)
336 _ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, dest.layout.ty),
342 src: OpTy<'tcx, M::PointerTag>,
343 dest: PlaceTy<'tcx, M::PointerTag>,
344 ) -> EvalResult<'tcx> {
345 match (&src.layout.ty.sty, &dest.layout.ty.sty) {
346 (&ty::Ref(_, s, _), &ty::Ref(_, d, _)) |
347 (&ty::Ref(_, s, _), &ty::RawPtr(TypeAndMut { ty: d, .. })) |
348 (&ty::RawPtr(TypeAndMut { ty: s, .. }),
349 &ty::RawPtr(TypeAndMut { ty: d, .. })) => {
350 self.unsize_into_ptr(src, dest, s, d)
352 (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
353 assert_eq!(def_a, def_b);
354 if def_a.is_box() || def_b.is_box() {
355 if !def_a.is_box() || !def_b.is_box() {
356 bug!("invalid unsizing between {:?} -> {:?}", src.layout, dest.layout);
358 return self.unsize_into_ptr(
361 src.layout.ty.boxed_ty(),
362 dest.layout.ty.boxed_ty(),
366 // unsizing of generic struct with pointer fields
367 // Example: `Arc<T>` -> `Arc<Trait>`
368 // here we need to increase the size of every &T thin ptr field to a fat ptr
369 for i in 0..src.layout.fields.count() {
370 let dst_field = self.place_field(dest, i as u64)?;
371 if dst_field.layout.is_zst() {
374 let src_field = match src.try_as_mplace() {
376 let src_field = self.mplace_field(mplace, i as u64)?;
380 let src_field_layout = src.layout.field(&self, i)?;
381 // this must be a field covering the entire thing
382 assert_eq!(src.layout.fields.offset(i).bytes(), 0);
383 assert_eq!(src_field_layout.size, src.layout.size);
384 // just sawp out the layout
385 OpTy { op: src.op, layout: src_field_layout }
388 if src_field.layout.ty == dst_field.layout.ty {
389 self.copy_op(src_field, dst_field)?;
391 self.unsize_into(src_field, dst_field)?;
398 "unsize_into: invalid conversion: {:?} -> {:?}",