compiler/rustc_const_eval/src/interpret/cast.rs

   1 use std::assert_matches::assert_matches;
   2 use std::convert::TryFrom;
   3
   4 use rustc_apfloat::ieee::{Double, Single};
   5 use rustc_apfloat::{Float, FloatConvert};
   6 use rustc_middle::mir::interpret::{InterpResult, PointerArithmetic, Scalar};
   7 use rustc_middle::mir::CastKind;
   8 use rustc_middle::ty::adjustment::PointerCast;
   9 use rustc_middle::ty::layout::{IntegerExt, LayoutOf, TyAndLayout};
  10 use rustc_middle::ty::{self, FloatTy, Ty, TypeAndMut};
  11 use rustc_target::abi::Integer;
  12 use rustc_type_ir::sty::TyKind::*;
  13
  14 use super::{
  15     util::ensure_monomorphic_enough, FnVal, ImmTy, Immediate, InterpCx, Machine, OpTy, PlaceTy,
  16 };
  17
  18 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  19     pub fn cast(
  20         &mut self,
  21         src: &OpTy<'tcx, M::PointerTag>,
  22         cast_kind: CastKind,
  23         cast_ty: Ty<'tcx>,
  24         dest: &PlaceTy<'tcx, M::PointerTag>,
  25     ) -> InterpResult<'tcx> {
  26         use rustc_middle::mir::CastKind::*;
  27         // FIXME: In which cases should we trigger UB when the source is uninit?
  28         match cast_kind {
  29             Pointer(PointerCast::Unsize) => {
  30                 let cast_ty = self.layout_of(cast_ty)?;
  31                 self.unsize_into(src, cast_ty, dest)?;
  32             }
  33
  34             PointerExposeAddress => {
  35                 let src = self.read_immediate(src)?;
  36                 let res = self.pointer_expose_address_cast(&src, cast_ty)?;
  37                 self.write_immediate(res, dest)?;
  38             }
  39
  40             PointerFromExposedAddress => {
  41                 let src = self.read_immediate(src)?;
  42                 let res = self.pointer_from_exposed_address_cast(&src, cast_ty)?;
  43                 self.write_immediate(res, dest)?;
  44             }
  45
  46             Misc => {
  47                 let src = self.read_immediate(src)?;
  48                 let res = self.misc_cast(&src, cast_ty)?;
  49                 self.write_immediate(res, dest)?;
  50             }
  51
  52             Pointer(PointerCast::MutToConstPointer | PointerCast::ArrayToPointer) => {
  53                 // These are NOPs, but can be wide pointers.
  54                 let v = self.read_immediate(src)?;
  55                 self.write_immediate(*v, dest)?;
  56             }
  57
  58             Pointer(PointerCast::ReifyFnPointer) => {
  59                 // The src operand does not matter, just its type
  60                 match *src.layout.ty.kind() {
  61                     ty::FnDef(def_id, substs) => {
  62                         // All reifications must be monomorphic, bail out otherwise.
  63                         ensure_monomorphic_enough(*self.tcx, src.layout.ty)?;
  64
  65                         let instance = ty::Instance::resolve_for_fn_ptr(
  66                             *self.tcx,
  67                             self.param_env,
  68                             def_id,
  69                             substs,
  70                         )
  71                         .ok_or_else(|| err_inval!(TooGeneric))?;
  72
  73                         let fn_ptr = self.create_fn_alloc_ptr(FnVal::Instance(instance));
  74                         self.write_pointer(fn_ptr, dest)?;
  75                     }
  76                     _ => span_bug!(self.cur_span(), "reify fn pointer on {:?}", src.layout.ty),
  77                 }
  78             }
  79
  80             Pointer(PointerCast::UnsafeFnPointer) => {
  81                 let src = self.read_immediate(src)?;
  82                 match cast_ty.kind() {
  83                     ty::FnPtr(_) => {
  84                         // No change to value
  85                         self.write_immediate(*src, dest)?;
  86                     }
  87                     _ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty),
  88                 }
  89             }
  90
  91             Pointer(PointerCast::ClosureFnPointer(_)) => {
  92                 // The src operand does not matter, just its type
  93                 match *src.layout.ty.kind() {
  94                     ty::Closure(def_id, substs) => {
  95                         // All reifications must be monomorphic, bail out otherwise.
  96                         ensure_monomorphic_enough(*self.tcx, src.layout.ty)?;
  97
  98                         let instance = ty::Instance::resolve_closure(
  99                             *self.tcx,
 100                             def_id,
 101                             substs,
 102                             ty::ClosureKind::FnOnce,
 103                         )
 104                         .ok_or_else(|| err_inval!(TooGeneric))?;
 105                         let fn_ptr = self.create_fn_alloc_ptr(FnVal::Instance(instance));
 106                         self.write_pointer(fn_ptr, dest)?;
 107                     }
 108                     _ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),
 109                 }
 110             }
 111         }
 112         Ok(())
 113     }
 114
 115     pub fn misc_cast(
 116         &mut self,
 117         src: &ImmTy<'tcx, M::PointerTag>,
 118         cast_ty: Ty<'tcx>,
 119     ) -> InterpResult<'tcx, Immediate<M::PointerTag>> {
 120         use rustc_type_ir::sty::TyKind::*;
 121         trace!("Casting {:?}: {:?} to {:?}", *src, src.layout.ty, cast_ty);
 122
 123         match src.layout.ty.kind() {
 124             // Floating point
 125             Float(FloatTy::F32) => {
 126                 return Ok(self.cast_from_float(src.to_scalar()?.to_f32()?, cast_ty).into());
 127             }
 128             Float(FloatTy::F64) => {
 129                 return Ok(self.cast_from_float(src.to_scalar()?.to_f64()?, cast_ty).into());
 130             }
 131             // The rest is integer/pointer-"like", including fn ptr casts
 132             _ => assert!(
 133                 src.layout.ty.is_bool()
 134                     || src.layout.ty.is_char()
 135                     || src.layout.ty.is_integral()
 136                     || src.layout.ty.is_any_ptr(),
 137                 "Unexpected cast from type {:?}",
 138                 src.layout.ty
 139             ),
 140         }
 141
 142         // # First handle non-scalar source values.
 143
 144         // Handle casting any ptr to raw ptr (might be a fat ptr).
 145         if src.layout.ty.is_any_ptr() && cast_ty.is_unsafe_ptr() {
 146             let dest_layout = self.layout_of(cast_ty)?;
 147             if dest_layout.size == src.layout.size {
 148                 // Thin or fat pointer that just hast the ptr kind of target type changed.
 149                 return Ok(**src);
 150             } else {
 151                 // Casting the metadata away from a fat ptr.
 152                 assert_eq!(src.layout.size, 2 * self.pointer_size());
 153                 assert_eq!(dest_layout.size, self.pointer_size());
 154                 assert!(src.layout.ty.is_unsafe_ptr());
 155                 return match **src {
 156                     Immediate::ScalarPair(data, _) => Ok(data.check_init()?.into()),
 157                     Immediate::Scalar(..) => span_bug!(
 158                         self.cur_span(),
 159                         "{:?} input to a fat-to-thin cast ({:?} -> {:?})",
 160                         *src,
 161                         src.layout.ty,
 162                         cast_ty
 163                     ),
 164                     Immediate::Uninit => throw_ub!(InvalidUninitBytes(None)),
 165                 };
 166             }
 167         }
 168
 169         // # The remaining source values are scalar and "int-like".
 170         let scalar = src.to_scalar()?;
 171         Ok(self.cast_from_int_like(scalar, src.layout, cast_ty)?.into())
 172     }
 173
 174     pub fn pointer_expose_address_cast(
 175         &mut self,
 176         src: &ImmTy<'tcx, M::PointerTag>,
 177         cast_ty: Ty<'tcx>,
 178     ) -> InterpResult<'tcx, Immediate<M::PointerTag>> {
 179         assert_matches!(src.layout.ty.kind(), ty::RawPtr(_) | ty::FnPtr(_));
 180         assert!(cast_ty.is_integral());
 181
 182         let scalar = src.to_scalar()?;
 183         let ptr = self.scalar_to_ptr(scalar)?;
 184         match ptr.into_pointer_or_addr() {
 185             Ok(ptr) => M::expose_ptr(self, ptr)?,
 186             Err(_) => {} // Do nothing, exposing an invalid pointer (`None` provenance) is a NOP.
 187         };
 188         Ok(self.cast_from_int_like(scalar, src.layout, cast_ty)?.into())
 189     }
 190
 191     pub fn pointer_from_exposed_address_cast(
 192         &mut self,
 193         src: &ImmTy<'tcx, M::PointerTag>,
 194         cast_ty: Ty<'tcx>,
 195     ) -> InterpResult<'tcx, Immediate<M::PointerTag>> {
 196         assert!(src.layout.ty.is_integral());
 197         assert_matches!(cast_ty.kind(), ty::RawPtr(_));
 198
 199         // First cast to usize.
 200         let scalar = src.to_scalar()?;
 201         let addr = self.cast_from_int_like(scalar, src.layout, self.tcx.types.usize)?;
 202         let addr = addr.to_machine_usize(self)?;
 203
 204         // Then turn address into pointer.
 205         let ptr = M::ptr_from_addr_cast(&self, addr)?;
 206         Ok(Scalar::from_maybe_pointer(ptr, self).into())
 207     }
 208
 209     pub fn cast_from_int_like(
 210         &self,
 211         scalar: Scalar<M::PointerTag>, // input value (there is no ScalarTy so we separate data+layout)
 212         src_layout: TyAndLayout<'tcx>,
 213         cast_ty: Ty<'tcx>,
 214     ) -> InterpResult<'tcx, Scalar<M::PointerTag>> {
 215         // Let's make sure v is sign-extended *if* it has a signed type.
 216         let signed = src_layout.abi.is_signed(); // Also asserts that abi is `Scalar`.
 217
 218         let v = scalar.to_bits(src_layout.size)?;
 219         let v = if signed { self.sign_extend(v, src_layout) } else { v };
 220         trace!("cast_from_scalar: {}, {} -> {}", v, src_layout.ty, cast_ty);
 221
 222         Ok(match *cast_ty.kind() {
 223             Int(_) | Uint(_) => {
 224                 let size = match *cast_ty.kind() {
 225                     Int(t) => Integer::from_int_ty(self, t).size(),
 226                     Uint(t) => Integer::from_uint_ty(self, t).size(),
 227                     _ => bug!(),
 228                 };
 229                 let v = size.truncate(v);
 230                 Scalar::from_uint(v, size)
 231             }
 232
 233             Float(FloatTy::F32) if signed => Scalar::from_f32(Single::from_i128(v as i128).value),
 234             Float(FloatTy::F64) if signed => Scalar::from_f64(Double::from_i128(v as i128).value),
 235             Float(FloatTy::F32) => Scalar::from_f32(Single::from_u128(v).value),
 236             Float(FloatTy::F64) => Scalar::from_f64(Double::from_u128(v).value),
 237
 238             Char => {
 239                 // `u8` to `char` cast
 240                 Scalar::from_u32(u8::try_from(v).unwrap().into())
 241             }
 242
 243             // Casts to bool are not permitted by rustc, no need to handle them here.
 244             _ => span_bug!(self.cur_span(), "invalid int to {:?} cast", cast_ty),
 245         })
 246     }
 247
 248     fn cast_from_float<F>(&self, f: F, dest_ty: Ty<'tcx>) -> Scalar<M::PointerTag>
 249     where
 250         F: Float + Into<Scalar<M::PointerTag>> + FloatConvert<Single> + FloatConvert<Double>,
 251     {
 252         use rustc_type_ir::sty::TyKind::*;
 253         match *dest_ty.kind() {
 254             // float -> uint
 255             Uint(t) => {
 256                 let size = Integer::from_uint_ty(self, t).size();
 257                 // `to_u128` is a saturating cast, which is what we need
 258                 // (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
 259                 let v = f.to_u128(size.bits_usize()).value;
 260                 // This should already fit the bit width
 261                 Scalar::from_uint(v, size)
 262             }
 263             // float -> int
 264             Int(t) => {
 265                 let size = Integer::from_int_ty(self, t).size();
 266                 // `to_i128` is a saturating cast, which is what we need
 267                 // (https://doc.rust-lang.org/nightly/nightly-rustc/rustc_apfloat/trait.Float.html#method.to_i128_r).
 268                 let v = f.to_i128(size.bits_usize()).value;
 269                 Scalar::from_int(v, size)
 270             }
 271             // float -> f32
 272             Float(FloatTy::F32) => Scalar::from_f32(f.convert(&mut false).value),
 273             // float -> f64
 274             Float(FloatTy::F64) => Scalar::from_f64(f.convert(&mut false).value),
 275             // That's it.
 276             _ => span_bug!(self.cur_span(), "invalid float to {:?} cast", dest_ty),
 277         }
 278     }
 279
 280     fn unsize_into_ptr(
 281         &mut self,
 282         src: &OpTy<'tcx, M::PointerTag>,
 283         dest: &PlaceTy<'tcx, M::PointerTag>,
 284         // The pointee types
 285         source_ty: Ty<'tcx>,
 286         cast_ty: Ty<'tcx>,
 287     ) -> InterpResult<'tcx> {
 288         // A<Struct> -> A<Trait> conversion
 289         let (src_pointee_ty, dest_pointee_ty) =
 290             self.tcx.struct_lockstep_tails_erasing_lifetimes(source_ty, cast_ty, self.param_env);
 291
 292         match (&src_pointee_ty.kind(), &dest_pointee_ty.kind()) {
 293             (&ty::Array(_, length), &ty::Slice(_)) => {
 294                 let ptr = self.read_immediate(src)?.to_scalar()?;
 295                 // u64 cast is from usize to u64, which is always good
 296                 let val =
 297                     Immediate::new_slice(ptr, length.eval_usize(*self.tcx, self.param_env), self);
 298                 self.write_immediate(val, dest)
 299             }
 300             (&ty::Dynamic(ref data_a, ..), &ty::Dynamic(ref data_b, ..)) => {
 301                 let val = self.read_immediate(src)?;
 302                 if data_a.principal_def_id() == data_b.principal_def_id() {
 303                     return self.write_immediate(*val, dest);
 304                 }
 305                 // trait upcasting coercion
 306                 let vptr_entry_idx = self.tcx.vtable_trait_upcasting_coercion_new_vptr_slot((
 307                     src_pointee_ty,
 308                     dest_pointee_ty,
 309                 ));
 310
 311                 if let Some(entry_idx) = vptr_entry_idx {
 312                     let entry_idx = u64::try_from(entry_idx).unwrap();
 313                     let (old_data, old_vptr) = val.to_scalar_pair()?;
 314                     let old_vptr = self.scalar_to_ptr(old_vptr)?;
 315                     let new_vptr = self
 316                         .read_new_vtable_after_trait_upcasting_from_vtable(old_vptr, entry_idx)?;
 317                     self.write_immediate(Immediate::new_dyn_trait(old_data, new_vptr, self), dest)
 318                 } else {
 319                     self.write_immediate(*val, dest)
 320                 }
 321             }
 322             (_, &ty::Dynamic(ref data, _)) => {
 323                 // Initial cast from sized to dyn trait
 324                 let vtable = self.get_vtable(src_pointee_ty, data.principal())?;
 325                 let ptr = self.read_immediate(src)?.to_scalar()?;
 326                 let val = Immediate::new_dyn_trait(ptr, vtable, &*self.tcx);
 327                 self.write_immediate(val, dest)
 328             }
 329
 330             _ => {
 331                 span_bug!(self.cur_span(), "invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty)
 332             }
 333         }
 334     }
 335
 336     fn unsize_into(
 337         &mut self,
 338         src: &OpTy<'tcx, M::PointerTag>,
 339         cast_ty: TyAndLayout<'tcx>,
 340         dest: &PlaceTy<'tcx, M::PointerTag>,
 341     ) -> InterpResult<'tcx> {
 342         trace!("Unsizing {:?} of type {} into {:?}", *src, src.layout.ty, cast_ty.ty);
 343         match (&src.layout.ty.kind(), &cast_ty.ty.kind()) {
 344             (&ty::Ref(_, s, _), &ty::Ref(_, c, _) | &ty::RawPtr(TypeAndMut { ty: c, .. }))
 345             | (&ty::RawPtr(TypeAndMut { ty: s, .. }), &ty::RawPtr(TypeAndMut { ty: c, .. })) => {
 346                 self.unsize_into_ptr(src, dest, *s, *c)
 347             }
 348             (&ty::Adt(def_a, _), &ty::Adt(def_b, _)) => {
 349                 assert_eq!(def_a, def_b);
 350
 351                 // unsizing of generic struct with pointer fields
 352                 // Example: `Arc<T>` -> `Arc<Trait>`
 353                 // here we need to increase the size of every &T thin ptr field to a fat ptr
 354                 for i in 0..src.layout.fields.count() {
 355                     let cast_ty_field = cast_ty.field(self, i);
 356                     if cast_ty_field.is_zst() {
 357                         continue;
 358                     }
 359                     let src_field = self.operand_field(src, i)?;
 360                     let dst_field = self.place_field(dest, i)?;
 361                     if src_field.layout.ty == cast_ty_field.ty {
 362                         self.copy_op(&src_field, &dst_field)?;
 363                     } else {
 364                         self.unsize_into(&src_field, cast_ty_field, &dst_field)?;
 365                     }
 366                 }
 367                 Ok(())
 368             }
 369             _ => span_bug!(
 370                 self.cur_span(),
 371                 "unsize_into: invalid conversion: {:?} -> {:?}",
 372                 src.layout,
 373                 dest.layout
 374             ),
 375         }
 376     }
 377 }