src/librustc_mir/interpret/cast.rs

   1 use rustc::ty::{self, Ty, TypeAndMut};
   2 use rustc::ty::layout::{self, TyLayout, Size};
   3 use syntax::ast::{FloatTy, IntTy, UintTy};
   4
   5 use rustc_apfloat::ieee::{Single, Double};
   6 use rustc::mir::interpret::{
   7     Scalar, EvalResult, Pointer, PointerArithmetic, EvalErrorKind, truncate
   8 };
   9 use rustc::mir::CastKind;
  10 use rustc_apfloat::Float;
  11
  12 use super::{EvalContext, Machine, PlaceTy, OpTy, ImmTy, Immediate};
  13
  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 {
  16         match ty.sty {
  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()),
  20             _ => false,
  21         }
  22     }
  23
  24     pub fn cast(
  25         &mut self,
  26         src: OpTy<'tcx, M::PointerTag>,
  27         kind: CastKind,
  28         dest: PlaceTy<'tcx, M::PointerTag>,
  29     ) -> EvalResult<'tcx> {
  30         use rustc::mir::CastKind::*;
  31         match kind {
  32             Unsize => {
  33                 self.unsize_into(src, dest)?;
  34             }
  35
  36             Misc => {
  37                 let src = self.read_immediate(src)?;
  38
  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)?;
  47                         }
  48                         // slices and trait objects to thin pointers (dropping the metadata)
  49                         (Immediate::ScalarPair(data, _), false) => {
  50                             self.write_scalar(data, dest)?;
  51                         }
  52                     }
  53                 } else {
  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());
  59                                 let discr_val = def
  60                                     .discriminant_for_variant(*self.tcx, index)
  61                                     .val;
  62                                 return self.write_scalar(
  63                                     Scalar::from_uint(discr_val, dest.layout.size),
  64                                     dest);
  65                             }
  66                         }
  67                         layout::Variants::Tagged { .. } |
  68                         layout::Variants::NicheFilling { .. } => {},
  69                     }
  70
  71                     let dest_val = self.cast_scalar(src.to_scalar()?, src.layout, dest.layout)?;
  72                     self.write_scalar(dest_val, dest)?;
  73                 }
  74             }
  75
  76             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, "rustc_args_required_const") {
  81                             bug!("reifying a fn ptr that requires \
  82                                     const arguments");
  83                         }
  84                         let instance: EvalResult<'tcx, _> = ty::Instance::resolve(
  85                             *self.tcx,
  86                             self.param_env,
  87                             def_id,
  88                             substs,
  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)?;
  92                     }
  93                     ref other => bug!("reify fn pointer on {:?}", other),
  94                 }
  95             }
  96
  97             UnsafeFnPointer => {
  98                 let src = self.read_immediate(src)?;
  99                 match dest.layout.ty.sty {
 100                     ty::FnPtr(_) => {
 101                         // No change to value
 102                         self.write_immediate(*src, dest)?;
 103                     }
 104                     ref other => bug!("fn to unsafe fn cast on {:?}", other),
 105                 }
 106             }
 107
 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(
 114                             *self.tcx,
 115                             def_id,
 116                             substs,
 117                             ty::ClosureKind::FnOnce,
 118                         );
 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)?;
 122                     }
 123                     ref other => bug!("closure fn pointer on {:?}", other),
 124                 }
 125             }
 126         }
 127         Ok(())
 128     }
 129
 130     pub(super) fn cast_scalar(
 131         &self,
 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);
 138
 139         match val {
 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);
 145
 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)?,
 149                 };
 150
 151                 // Sanity check
 152                 match res {
 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);
 158                     }
 159                 }
 160                 // Done
 161                 Ok(res)
 162             }
 163         }
 164     }
 165
 166     fn cast_from_int(
 167         &self,
 168         v: u128,
 169         src_layout: TyLayout<'tcx>,
 170         dest_layout: TyLayout<'tcx>,
 171     ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
 172         let signed = src_layout.abi.is_signed();
 173         let v = if signed {
 174             self.sign_extend(v, src_layout)
 175         } else {
 176             v
 177         };
 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))
 184             }
 185
 186             Float(FloatTy::F32) if signed => Ok(Scalar::from_uint(
 187                 Single::from_i128(v as i128).value.to_bits(),
 188                 Size::from_bits(32)
 189             )),
 190             Float(FloatTy::F64) if signed => Ok(Scalar::from_uint(
 191                 Double::from_i128(v as i128).value.to_bits(),
 192                 Size::from_bits(64)
 193             )),
 194             Float(FloatTy::F32) => Ok(Scalar::from_uint(
 195                 Single::from_u128(v).value.to_bits(),
 196                 Size::from_bits(32)
 197             )),
 198             Float(FloatTy::F64) => Ok(Scalar::from_uint(
 199                 Double::from_u128(v).value.to_bits(),
 200                 Size::from_bits(64)
 201             )),
 202
 203             Char => {
 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)))
 207             },
 208
 209             // No alignment check needed for raw pointers.
 210             // But we have to truncate to target ptr size.
 211             RawPtr(_) => {
 212                 Ok(Scalar::from_uint(
 213                     self.truncate_to_ptr(v).0,
 214                     self.pointer_size(),
 215                 ))
 216             },
 217
 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))),
 220         }
 221     }
 222
 223     fn cast_from_float(
 224         &self,
 225         bits: u128,
 226         fty: FloatTy,
 227         dest_ty: Ty<'tcx>
 228     ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
 229         use rustc::ty::TyKind::*;
 230         use rustc_apfloat::FloatConvert;
 231         match dest_ty.sty {
 232             // float -> uint
 233             Uint(t) => {
 234                 let width = t.bit_width().unwrap_or_else(|| self.pointer_size().bits() as usize);
 235                 let v = match fty {
 236                     FloatTy::F32 => Single::from_bits(bits).to_u128(width).value,
 237                     FloatTy::F64 => Double::from_bits(bits).to_u128(width).value,
 238                 };
 239                 // This should already fit the bit width
 240                 Ok(Scalar::from_uint(v, Size::from_bits(width as u64)))
 241             },
 242             // float -> int
 243             Int(t) => {
 244                 let width = t.bit_width().unwrap_or_else(|| self.pointer_size().bits() as usize);
 245                 let v = match fty {
 246                     FloatTy::F32 => Single::from_bits(bits).to_i128(width).value,
 247                     FloatTy::F64 => Double::from_bits(bits).to_i128(width).value,
 248                 };
 249                 Ok(Scalar::from_int(v, Size::from_bits(width as u64)))
 250             },
 251             // f64 -> f32
 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),
 255                     Size::from_bits(32),
 256                 ))
 257             },
 258             // f32 -> f64
 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),
 262                     Size::from_bits(64),
 263                 ))
 264             },
 265             // identity cast
 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))),
 269         }
 270     }
 271
 272     fn cast_from_ptr(
 273         &self,
 274         ptr: Pointer<M::PointerTag>,
 275         ty: Ty<'tcx>
 276     ) -> EvalResult<'tcx, Scalar<M::PointerTag>> {
 277         use rustc::ty::TyKind::*;
 278         match ty.sty {
 279             // Casting to a reference or fn pointer is not permitted by rustc,
 280             // no need to support it here.
 281             RawPtr(_) |
 282             Int(IntTy::Isize) |
 283             Uint(UintTy::Usize) => Ok(ptr.into()),
 284             Int(_) | Uint(_) => err!(ReadPointerAsBytes),
 285             _ => err!(Unimplemented(format!("ptr to {:?} cast", ty))),
 286         }
 287     }
 288
 289     fn unsize_into_ptr(
 290         &mut self,
 291         src: OpTy<'tcx, M::PointerTag>,
 292         dest: PlaceTy<'tcx, M::PointerTag>,
 293         // The pointee types
 294         sty: Ty<'tcx>,
 295         dty: Ty<'tcx>,
 296     ) -> EvalResult<'tcx> {
 297         // A<Struct> -> A<Trait> conversion
 298         let (src_pointee_ty, dest_pointee_ty) = self.tcx.struct_lockstep_tails(sty, dty);
 299
 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(
 305                     ptr,
 306                     length.unwrap_usize(self.tcx.tcx),
 307                     self,
 308                 );
 309                 self.write_immediate(val, dest)
 310             }
 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)
 317             }
 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)
 324             }
 325
 326             _ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, dest.layout.ty),
 327         }
 328     }
 329
 330     fn unsize_into(
 331         &mut self,
 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)
 341             }
 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);
 347                     }
 348                     return self.unsize_into_ptr(
 349                         src,
 350                         dest,
 351                         src.layout.ty.boxed_ty(),
 352                         dest.layout.ty.boxed_ty(),
 353                     );
 354                 }
 355
 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() {
 362                         continue;
 363                     }
 364                     let src_field = match src.try_as_mplace() {
 365                         Ok(mplace) => {
 366                             let src_field = self.mplace_field(mplace, i as u64)?;
 367                             src_field.into()
 368                         }
 369                         Err(..) => {
 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 })
 376                         }
 377                     };
 378                     if src_field.layout.ty == dst_field.layout.ty {
 379                         self.copy_op(src_field, dst_field)?;
 380                     } else {
 381                         self.unsize_into(src_field, dst_field)?;
 382                     }
 383                 }
 384                 Ok(())
 385             }
 386             _ => {
 387                 bug!(
 388                     "unsize_into: invalid conversion: {:?} -> {:?}",
 389                     src.layout,
 390                     dest.layout
 391                 )
 392             }
 393         }
 394     }
 395 }