compiler/rustc_codegen_cranelift/src/value_and_place.rs

   1 //! Definition of [`CValue`] and [`CPlace`]
   2
   3 use crate::prelude::*;
   4
   5 use cranelift_codegen::entity::EntityRef;
   6 use cranelift_codegen::ir::immediates::Offset32;
   7
   8 fn codegen_field<'tcx>(
   9     fx: &mut FunctionCx<'_, 'tcx, impl Module>,
  10     base: Pointer,
  11     extra: Option<Value>,
  12     layout: TyAndLayout<'tcx>,
  13     field: mir::Field,
  14 ) -> (Pointer, TyAndLayout<'tcx>) {
  15     let field_offset = layout.fields.offset(field.index());
  16     let field_layout = layout.field(&*fx, field.index());
  17
  18     let simple = |fx: &mut FunctionCx<'_, '_, _>| {
  19         (
  20             base.offset_i64(fx, i64::try_from(field_offset.bytes()).unwrap()),
  21             field_layout,
  22         )
  23     };
  24
  25     if let Some(extra) = extra {
  26         if !field_layout.is_unsized() {
  27             return simple(fx);
  28         }
  29         match field_layout.ty.kind() {
  30             ty::Slice(..) | ty::Str | ty::Foreign(..) => simple(fx),
  31             ty::Adt(def, _) if def.repr.packed() => {
  32                 assert_eq!(layout.align.abi.bytes(), 1);
  33                 simple(fx)
  34             }
  35             _ => {
  36                 // We have to align the offset for DST's
  37                 let unaligned_offset = field_offset.bytes();
  38                 let (_, unsized_align) =
  39                     crate::unsize::size_and_align_of_dst(fx, field_layout, extra);
  40
  41                 let one = fx.bcx.ins().iconst(pointer_ty(fx.tcx), 1);
  42                 let align_sub_1 = fx.bcx.ins().isub(unsized_align, one);
  43                 let and_lhs = fx.bcx.ins().iadd_imm(align_sub_1, unaligned_offset as i64);
  44                 let zero = fx.bcx.ins().iconst(pointer_ty(fx.tcx), 0);
  45                 let and_rhs = fx.bcx.ins().isub(zero, unsized_align);
  46                 let offset = fx.bcx.ins().band(and_lhs, and_rhs);
  47
  48                 (base.offset_value(fx, offset), field_layout)
  49             }
  50         }
  51     } else {
  52         simple(fx)
  53     }
  54 }
  55
  56 fn scalar_pair_calculate_b_offset(
  57     tcx: TyCtxt<'_>,
  58     a_scalar: &Scalar,
  59     b_scalar: &Scalar,
  60 ) -> Offset32 {
  61     let b_offset = a_scalar
  62         .value
  63         .size(&tcx)
  64         .align_to(b_scalar.value.align(&tcx).abi);
  65     Offset32::new(b_offset.bytes().try_into().unwrap())
  66 }
  67
  68 /// A read-only value
  69 #[derive(Debug, Copy, Clone)]
  70 pub(crate) struct CValue<'tcx>(CValueInner, TyAndLayout<'tcx>);
  71
  72 #[derive(Debug, Copy, Clone)]
  73 enum CValueInner {
  74     ByRef(Pointer, Option<Value>),
  75     ByVal(Value),
  76     ByValPair(Value, Value),
  77 }
  78
  79 impl<'tcx> CValue<'tcx> {
  80     pub(crate) fn by_ref(ptr: Pointer, layout: TyAndLayout<'tcx>) -> CValue<'tcx> {
  81         CValue(CValueInner::ByRef(ptr, None), layout)
  82     }
  83
  84     pub(crate) fn by_ref_unsized(
  85         ptr: Pointer,
  86         meta: Value,
  87         layout: TyAndLayout<'tcx>,
  88     ) -> CValue<'tcx> {
  89         CValue(CValueInner::ByRef(ptr, Some(meta)), layout)
  90     }
  91
  92     pub(crate) fn by_val(value: Value, layout: TyAndLayout<'tcx>) -> CValue<'tcx> {
  93         CValue(CValueInner::ByVal(value), layout)
  94     }
  95
  96     pub(crate) fn by_val_pair(
  97         value: Value,
  98         extra: Value,
  99         layout: TyAndLayout<'tcx>,
 100     ) -> CValue<'tcx> {
 101         CValue(CValueInner::ByValPair(value, extra), layout)
 102     }
 103
 104     pub(crate) fn layout(&self) -> TyAndLayout<'tcx> {
 105         self.1
 106     }
 107
 108     // FIXME remove
 109     pub(crate) fn force_stack(
 110         self,
 111         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 112     ) -> (Pointer, Option<Value>) {
 113         let layout = self.1;
 114         match self.0 {
 115             CValueInner::ByRef(ptr, meta) => (ptr, meta),
 116             CValueInner::ByVal(_) | CValueInner::ByValPair(_, _) => {
 117                 let cplace = CPlace::new_stack_slot(fx, layout);
 118                 cplace.write_cvalue(fx, self);
 119                 (cplace.to_ptr(), None)
 120             }
 121         }
 122     }
 123
 124     pub(crate) fn try_to_ptr(self) -> Option<(Pointer, Option<Value>)> {
 125         match self.0 {
 126             CValueInner::ByRef(ptr, meta) => Some((ptr, meta)),
 127             CValueInner::ByVal(_) | CValueInner::ByValPair(_, _) => None,
 128         }
 129     }
 130
 131     /// Load a value with layout.abi of scalar
 132     pub(crate) fn load_scalar(self, fx: &mut FunctionCx<'_, 'tcx, impl Module>) -> Value {
 133         let layout = self.1;
 134         match self.0 {
 135             CValueInner::ByRef(ptr, None) => {
 136                 let clif_ty = match layout.abi {
 137                     Abi::Scalar(ref scalar) => scalar_to_clif_type(fx.tcx, scalar.clone()),
 138                     Abi::Vector { ref element, count } => {
 139                         scalar_to_clif_type(fx.tcx, element.clone())
 140                             .by(u16::try_from(count).unwrap())
 141                             .unwrap()
 142                     }
 143                     _ => unreachable!("{:?}", layout.ty),
 144                 };
 145                 let mut flags = MemFlags::new();
 146                 flags.set_notrap();
 147                 ptr.load(fx, clif_ty, flags)
 148             }
 149             CValueInner::ByVal(value) => value,
 150             CValueInner::ByRef(_, Some(_)) => bug!("load_scalar for unsized value not allowed"),
 151             CValueInner::ByValPair(_, _) => bug!("Please use load_scalar_pair for ByValPair"),
 152         }
 153     }
 154
 155     /// Load a value pair with layout.abi of scalar pair
 156     pub(crate) fn load_scalar_pair(
 157         self,
 158         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 159     ) -> (Value, Value) {
 160         let layout = self.1;
 161         match self.0 {
 162             CValueInner::ByRef(ptr, None) => {
 163                 let (a_scalar, b_scalar) = match &layout.abi {
 164                     Abi::ScalarPair(a, b) => (a, b),
 165                     _ => unreachable!("load_scalar_pair({:?})", self),
 166                 };
 167                 let b_offset = scalar_pair_calculate_b_offset(fx.tcx, a_scalar, b_scalar);
 168                 let clif_ty1 = scalar_to_clif_type(fx.tcx, a_scalar.clone());
 169                 let clif_ty2 = scalar_to_clif_type(fx.tcx, b_scalar.clone());
 170                 let mut flags = MemFlags::new();
 171                 flags.set_notrap();
 172                 let val1 = ptr.load(fx, clif_ty1, flags);
 173                 let val2 = ptr.offset(fx, b_offset).load(fx, clif_ty2, flags);
 174                 (val1, val2)
 175             }
 176             CValueInner::ByRef(_, Some(_)) => {
 177                 bug!("load_scalar_pair for unsized value not allowed")
 178             }
 179             CValueInner::ByVal(_) => bug!("Please use load_scalar for ByVal"),
 180             CValueInner::ByValPair(val1, val2) => (val1, val2),
 181         }
 182     }
 183
 184     pub(crate) fn value_field(
 185         self,
 186         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 187         field: mir::Field,
 188     ) -> CValue<'tcx> {
 189         let layout = self.1;
 190         match self.0 {
 191             CValueInner::ByVal(val) => match layout.abi {
 192                 Abi::Vector { element: _, count } => {
 193                     let count = u8::try_from(count).expect("SIMD type with more than 255 lanes???");
 194                     let field = u8::try_from(field.index()).unwrap();
 195                     assert!(field < count);
 196                     let lane = fx.bcx.ins().extractlane(val, field);
 197                     let field_layout = layout.field(&*fx, usize::from(field));
 198                     CValue::by_val(lane, field_layout)
 199                 }
 200                 _ => unreachable!("value_field for ByVal with abi {:?}", layout.abi),
 201             },
 202             CValueInner::ByValPair(val1, val2) => match layout.abi {
 203                 Abi::ScalarPair(_, _) => {
 204                     let val = match field.as_u32() {
 205                         0 => val1,
 206                         1 => val2,
 207                         _ => bug!("field should be 0 or 1"),
 208                     };
 209                     let field_layout = layout.field(&*fx, usize::from(field));
 210                     CValue::by_val(val, field_layout)
 211                 }
 212                 _ => unreachable!("value_field for ByValPair with abi {:?}", layout.abi),
 213             },
 214             CValueInner::ByRef(ptr, None) => {
 215                 let (field_ptr, field_layout) = codegen_field(fx, ptr, None, layout, field);
 216                 CValue::by_ref(field_ptr, field_layout)
 217             }
 218             CValueInner::ByRef(_, Some(_)) => todo!(),
 219         }
 220     }
 221
 222     pub(crate) fn unsize_value(
 223         self,
 224         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 225         dest: CPlace<'tcx>,
 226     ) {
 227         crate::unsize::coerce_unsized_into(fx, self, dest);
 228     }
 229
 230     /// If `ty` is signed, `const_val` must already be sign extended.
 231     pub(crate) fn const_val(
 232         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 233         layout: TyAndLayout<'tcx>,
 234         const_val: ty::ScalarInt,
 235     ) -> CValue<'tcx> {
 236         assert_eq!(const_val.size(), layout.size);
 237         use cranelift_codegen::ir::immediates::{Ieee32, Ieee64};
 238
 239         let clif_ty = fx.clif_type(layout.ty).unwrap();
 240
 241         if let ty::Bool = layout.ty.kind() {
 242             assert!(
 243                 const_val == ty::ScalarInt::FALSE || const_val == ty::ScalarInt::TRUE,
 244                 "Invalid bool 0x{:032X}",
 245                 const_val
 246             );
 247         }
 248
 249         let val = match layout.ty.kind() {
 250             ty::Uint(UintTy::U128) | ty::Int(IntTy::I128) => {
 251                 let const_val = const_val.to_bits(layout.size).unwrap();
 252                 let lsb = fx.bcx.ins().iconst(types::I64, const_val as u64 as i64);
 253                 let msb = fx
 254                     .bcx
 255                     .ins()
 256                     .iconst(types::I64, (const_val >> 64) as u64 as i64);
 257                 fx.bcx.ins().iconcat(lsb, msb)
 258             }
 259             ty::Bool | ty::Char | ty::Uint(_) | ty::Int(_) | ty::Ref(..)
 260             | ty::RawPtr(..) => {
 261                 fx
 262                     .bcx
 263                     .ins()
 264                     .iconst(clif_ty, const_val.to_bits(layout.size).unwrap() as i64)
 265             }
 266             ty::Float(FloatTy::F32) => {
 267                 fx.bcx.ins().f32const(Ieee32::with_bits(u32::try_from(const_val).unwrap()))
 268             }
 269             ty::Float(FloatTy::F64) => {
 270                 fx.bcx.ins().f64const(Ieee64::with_bits(u64::try_from(const_val).unwrap()))
 271             }
 272             _ => panic!(
 273                 "CValue::const_val for non bool/char/float/integer/pointer type {:?} is not allowed",
 274                 layout.ty
 275             ),
 276         };
 277
 278         CValue::by_val(val, layout)
 279     }
 280
 281     pub(crate) fn cast_pointer_to(self, layout: TyAndLayout<'tcx>) -> Self {
 282         assert!(matches!(
 283             self.layout().ty.kind(),
 284             ty::Ref(..) | ty::RawPtr(..) | ty::FnPtr(..)
 285         ));
 286         assert!(matches!(
 287             layout.ty.kind(),
 288             ty::Ref(..) | ty::RawPtr(..) | ty::FnPtr(..)
 289         ));
 290         assert_eq!(self.layout().abi, layout.abi);
 291         CValue(self.0, layout)
 292     }
 293 }
 294
 295 /// A place where you can write a value to or read a value from
 296 #[derive(Debug, Copy, Clone)]
 297 pub(crate) struct CPlace<'tcx> {
 298     inner: CPlaceInner,
 299     layout: TyAndLayout<'tcx>,
 300 }
 301
 302 #[derive(Debug, Copy, Clone)]
 303 pub(crate) enum CPlaceInner {
 304     Var(Local, Variable),
 305     VarPair(Local, Variable, Variable),
 306     VarLane(Local, Variable, u8),
 307     Addr(Pointer, Option<Value>),
 308 }
 309
 310 impl<'tcx> CPlace<'tcx> {
 311     pub(crate) fn layout(&self) -> TyAndLayout<'tcx> {
 312         self.layout
 313     }
 314
 315     pub(crate) fn inner(&self) -> &CPlaceInner {
 316         &self.inner
 317     }
 318
 319     pub(crate) fn no_place(layout: TyAndLayout<'tcx>) -> CPlace<'tcx> {
 320         CPlace {
 321             inner: CPlaceInner::Addr(Pointer::dangling(layout.align.pref), None),
 322             layout,
 323         }
 324     }
 325
 326     pub(crate) fn new_stack_slot(
 327         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 328         layout: TyAndLayout<'tcx>,
 329     ) -> CPlace<'tcx> {
 330         assert!(!layout.is_unsized());
 331         if layout.size.bytes() == 0 {
 332             return CPlace::no_place(layout);
 333         }
 334
 335         let stack_slot = fx.bcx.create_stack_slot(StackSlotData {
 336             kind: StackSlotKind::ExplicitSlot,
 337             size: u32::try_from(layout.size.bytes()).unwrap(),
 338             offset: None,
 339         });
 340         CPlace {
 341             inner: CPlaceInner::Addr(Pointer::stack_slot(stack_slot), None),
 342             layout,
 343         }
 344     }
 345
 346     pub(crate) fn new_var(
 347         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 348         local: Local,
 349         layout: TyAndLayout<'tcx>,
 350     ) -> CPlace<'tcx> {
 351         let var = Variable::with_u32(fx.next_ssa_var);
 352         fx.next_ssa_var += 1;
 353         fx.bcx.declare_var(var, fx.clif_type(layout.ty).unwrap());
 354         CPlace {
 355             inner: CPlaceInner::Var(local, var),
 356             layout,
 357         }
 358     }
 359
 360     pub(crate) fn new_var_pair(
 361         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 362         local: Local,
 363         layout: TyAndLayout<'tcx>,
 364     ) -> CPlace<'tcx> {
 365         let var1 = Variable::with_u32(fx.next_ssa_var);
 366         fx.next_ssa_var += 1;
 367         let var2 = Variable::with_u32(fx.next_ssa_var);
 368         fx.next_ssa_var += 1;
 369
 370         let (ty1, ty2) = fx.clif_pair_type(layout.ty).unwrap();
 371         fx.bcx.declare_var(var1, ty1);
 372         fx.bcx.declare_var(var2, ty2);
 373         CPlace {
 374             inner: CPlaceInner::VarPair(local, var1, var2),
 375             layout,
 376         }
 377     }
 378
 379     pub(crate) fn for_ptr(ptr: Pointer, layout: TyAndLayout<'tcx>) -> CPlace<'tcx> {
 380         CPlace {
 381             inner: CPlaceInner::Addr(ptr, None),
 382             layout,
 383         }
 384     }
 385
 386     pub(crate) fn for_ptr_with_extra(
 387         ptr: Pointer,
 388         extra: Value,
 389         layout: TyAndLayout<'tcx>,
 390     ) -> CPlace<'tcx> {
 391         CPlace {
 392             inner: CPlaceInner::Addr(ptr, Some(extra)),
 393             layout,
 394         }
 395     }
 396
 397     pub(crate) fn to_cvalue(self, fx: &mut FunctionCx<'_, 'tcx, impl Module>) -> CValue<'tcx> {
 398         let layout = self.layout();
 399         match self.inner {
 400             CPlaceInner::Var(_local, var) => {
 401                 let val = fx.bcx.use_var(var);
 402                 fx.bcx
 403                     .set_val_label(val, cranelift_codegen::ir::ValueLabel::new(var.index()));
 404                 CValue::by_val(val, layout)
 405             }
 406             CPlaceInner::VarPair(_local, var1, var2) => {
 407                 let val1 = fx.bcx.use_var(var1);
 408                 fx.bcx
 409                     .set_val_label(val1, cranelift_codegen::ir::ValueLabel::new(var1.index()));
 410                 let val2 = fx.bcx.use_var(var2);
 411                 fx.bcx
 412                     .set_val_label(val2, cranelift_codegen::ir::ValueLabel::new(var2.index()));
 413                 CValue::by_val_pair(val1, val2, layout)
 414             }
 415             CPlaceInner::VarLane(_local, var, lane) => {
 416                 let val = fx.bcx.use_var(var);
 417                 fx.bcx
 418                     .set_val_label(val, cranelift_codegen::ir::ValueLabel::new(var.index()));
 419                 let val = fx.bcx.ins().extractlane(val, lane);
 420                 CValue::by_val(val, layout)
 421             }
 422             CPlaceInner::Addr(ptr, extra) => {
 423                 if let Some(extra) = extra {
 424                     CValue::by_ref_unsized(ptr, extra, layout)
 425                 } else {
 426                     CValue::by_ref(ptr, layout)
 427                 }
 428             }
 429         }
 430     }
 431
 432     pub(crate) fn to_ptr(self) -> Pointer {
 433         match self.to_ptr_maybe_unsized() {
 434             (ptr, None) => ptr,
 435             (_, Some(_)) => bug!("Expected sized cplace, found {:?}", self),
 436         }
 437     }
 438
 439     pub(crate) fn to_ptr_maybe_unsized(self) -> (Pointer, Option<Value>) {
 440         match self.inner {
 441             CPlaceInner::Addr(ptr, extra) => (ptr, extra),
 442             CPlaceInner::Var(_, _)
 443             | CPlaceInner::VarPair(_, _, _)
 444             | CPlaceInner::VarLane(_, _, _) => bug!("Expected CPlace::Addr, found {:?}", self),
 445         }
 446     }
 447
 448     pub(crate) fn write_cvalue(
 449         self,
 450         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 451         from: CValue<'tcx>,
 452     ) {
 453         fn assert_assignable<'tcx>(
 454             fx: &FunctionCx<'_, 'tcx, impl Module>,
 455             from_ty: Ty<'tcx>,
 456             to_ty: Ty<'tcx>,
 457         ) {
 458             match (from_ty.kind(), to_ty.kind()) {
 459                 (ty::Ref(_, a, _), ty::Ref(_, b, _))
 460                 | (
 461                     ty::RawPtr(TypeAndMut { ty: a, mutbl: _ }),
 462                     ty::RawPtr(TypeAndMut { ty: b, mutbl: _ }),
 463                 ) => {
 464                     assert_assignable(fx, a, b);
 465                 }
 466                 (ty::FnPtr(_), ty::FnPtr(_)) => {
 467                     let from_sig = fx.tcx.normalize_erasing_late_bound_regions(
 468                         ParamEnv::reveal_all(),
 469                         from_ty.fn_sig(fx.tcx),
 470                     );
 471                     let to_sig = fx.tcx.normalize_erasing_late_bound_regions(
 472                         ParamEnv::reveal_all(),
 473                         to_ty.fn_sig(fx.tcx),
 474                     );
 475                     assert_eq!(
 476                         from_sig, to_sig,
 477                         "Can't write fn ptr with incompatible sig {:?} to place with sig {:?}\n\n{:#?}",
 478                         from_sig, to_sig, fx,
 479                     );
 480                     // fn(&T) -> for<'l> fn(&'l T) is allowed
 481                 }
 482                 (&ty::Dynamic(from_traits, _), &ty::Dynamic(to_traits, _)) => {
 483                     let from_traits = fx
 484                         .tcx
 485                         .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), from_traits);
 486                     let to_traits = fx
 487                         .tcx
 488                         .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), to_traits);
 489                     assert_eq!(
 490                         from_traits, to_traits,
 491                         "Can't write trait object of incompatible traits {:?} to place with traits {:?}\n\n{:#?}",
 492                         from_traits, to_traits, fx,
 493                     );
 494                     // dyn for<'r> Trait<'r> -> dyn Trait<'_> is allowed
 495                 }
 496                 _ => {
 497                     assert_eq!(
 498                         from_ty,
 499                         to_ty,
 500                         "Can't write value with incompatible type {:?} to place with type {:?}\n\n{:#?}",
 501                         from_ty,
 502                         to_ty,
 503                         fx,
 504                     );
 505                 }
 506             }
 507         }
 508
 509         assert_assignable(fx, from.layout().ty, self.layout().ty);
 510
 511         self.write_cvalue_maybe_transmute(fx, from, "write_cvalue");
 512     }
 513
 514     pub(crate) fn write_cvalue_transmute(
 515         self,
 516         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 517         from: CValue<'tcx>,
 518     ) {
 519         self.write_cvalue_maybe_transmute(fx, from, "write_cvalue_transmute");
 520     }
 521
 522     fn write_cvalue_maybe_transmute(
 523         self,
 524         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 525         from: CValue<'tcx>,
 526         #[cfg_attr(not(debug_assertions), allow(unused_variables))] method: &'static str,
 527     ) {
 528         fn transmute_value<'tcx>(
 529             fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 530             var: Variable,
 531             data: Value,
 532             dst_ty: Type,
 533         ) {
 534             let src_ty = fx.bcx.func.dfg.value_type(data);
 535             assert_eq!(
 536                 src_ty.bytes(),
 537                 dst_ty.bytes(),
 538                 "write_cvalue_transmute: {:?} -> {:?}",
 539                 src_ty,
 540                 dst_ty,
 541             );
 542             let data = match (src_ty, dst_ty) {
 543                 (_, _) if src_ty == dst_ty => data,
 544
 545                 // This is a `write_cvalue_transmute`.
 546                 (types::I32, types::F32)
 547                 | (types::F32, types::I32)
 548                 | (types::I64, types::F64)
 549                 | (types::F64, types::I64) => fx.bcx.ins().bitcast(dst_ty, data),
 550                 _ if src_ty.is_vector() && dst_ty.is_vector() => {
 551                     fx.bcx.ins().raw_bitcast(dst_ty, data)
 552                 }
 553                 _ if src_ty.is_vector() || dst_ty.is_vector() => {
 554                     // FIXME do something more efficient for transmutes between vectors and integers.
 555                     let stack_slot = fx.bcx.create_stack_slot(StackSlotData {
 556                         kind: StackSlotKind::ExplicitSlot,
 557                         size: src_ty.bytes(),
 558                         offset: None,
 559                     });
 560                     let ptr = Pointer::stack_slot(stack_slot);
 561                     ptr.store(fx, data, MemFlags::trusted());
 562                     ptr.load(fx, dst_ty, MemFlags::trusted())
 563                 }
 564                 _ => unreachable!("write_cvalue_transmute: {:?} -> {:?}", src_ty, dst_ty),
 565             };
 566             fx.bcx
 567                 .set_val_label(data, cranelift_codegen::ir::ValueLabel::new(var.index()));
 568             fx.bcx.def_var(var, data);
 569         }
 570
 571         assert_eq!(self.layout().size, from.layout().size);
 572
 573         #[cfg(debug_assertions)]
 574         {
 575             use cranelift_codegen::cursor::{Cursor, CursorPosition};
 576             let cur_block = match fx.bcx.cursor().position() {
 577                 CursorPosition::After(block) => block,
 578                 _ => unreachable!(),
 579             };
 580             fx.add_comment(
 581                 fx.bcx.func.layout.last_inst(cur_block).unwrap(),
 582                 format!(
 583                     "{}: {:?}: {:?} <- {:?}: {:?}",
 584                     method,
 585                     self.inner(),
 586                     self.layout().ty,
 587                     from.0,
 588                     from.layout().ty
 589                 ),
 590             );
 591         }
 592
 593         let dst_layout = self.layout();
 594         let to_ptr = match self.inner {
 595             CPlaceInner::Var(_local, var) => {
 596                 let data = CValue(from.0, dst_layout).load_scalar(fx);
 597                 let dst_ty = fx.clif_type(self.layout().ty).unwrap();
 598                 transmute_value(fx, var, data, dst_ty);
 599                 return;
 600             }
 601             CPlaceInner::VarPair(_local, var1, var2) => {
 602                 let (data1, data2) = CValue(from.0, dst_layout).load_scalar_pair(fx);
 603                 let (dst_ty1, dst_ty2) = fx.clif_pair_type(self.layout().ty).unwrap();
 604                 transmute_value(fx, var1, data1, dst_ty1);
 605                 transmute_value(fx, var2, data2, dst_ty2);
 606                 return;
 607             }
 608             CPlaceInner::VarLane(_local, var, lane) => {
 609                 let data = from.load_scalar(fx);
 610
 611                 // First get the old vector
 612                 let vector = fx.bcx.use_var(var);
 613                 fx.bcx
 614                     .set_val_label(vector, cranelift_codegen::ir::ValueLabel::new(var.index()));
 615
 616                 // Next insert the written lane into the vector
 617                 let vector = fx.bcx.ins().insertlane(vector, data, lane);
 618
 619                 // Finally write the new vector
 620                 fx.bcx
 621                     .set_val_label(vector, cranelift_codegen::ir::ValueLabel::new(var.index()));
 622                 fx.bcx.def_var(var, vector);
 623
 624                 return;
 625             }
 626             CPlaceInner::Addr(ptr, None) => {
 627                 if dst_layout.size == Size::ZERO || dst_layout.abi == Abi::Uninhabited {
 628                     return;
 629                 }
 630                 ptr
 631             }
 632             CPlaceInner::Addr(_, Some(_)) => bug!("Can't write value to unsized place {:?}", self),
 633         };
 634
 635         let mut flags = MemFlags::new();
 636         flags.set_notrap();
 637         match from.layout().abi {
 638             // FIXME make Abi::Vector work too
 639             Abi::Scalar(_) => {
 640                 let val = from.load_scalar(fx);
 641                 to_ptr.store(fx, val, flags);
 642                 return;
 643             }
 644             Abi::ScalarPair(ref a_scalar, ref b_scalar) => {
 645                 let (value, extra) = from.load_scalar_pair(fx);
 646                 let b_offset = scalar_pair_calculate_b_offset(fx.tcx, a_scalar, b_scalar);
 647                 to_ptr.store(fx, value, flags);
 648                 to_ptr.offset(fx, b_offset).store(fx, extra, flags);
 649                 return;
 650             }
 651             _ => {}
 652         }
 653
 654         match from.0 {
 655             CValueInner::ByVal(val) => {
 656                 to_ptr.store(fx, val, flags);
 657             }
 658             CValueInner::ByValPair(_, _) => {
 659                 bug!(
 660                     "Non ScalarPair abi {:?} for ByValPair CValue",
 661                     dst_layout.abi
 662                 );
 663             }
 664             CValueInner::ByRef(from_ptr, None) => {
 665                 let from_addr = from_ptr.get_addr(fx);
 666                 let to_addr = to_ptr.get_addr(fx);
 667                 let src_layout = from.1;
 668                 let size = dst_layout.size.bytes();
 669                 let src_align = src_layout.align.abi.bytes() as u8;
 670                 let dst_align = dst_layout.align.abi.bytes() as u8;
 671                 fx.bcx.emit_small_memory_copy(
 672                     fx.cx.module.target_config(),
 673                     to_addr,
 674                     from_addr,
 675                     size,
 676                     dst_align,
 677                     src_align,
 678                     true,
 679                 );
 680             }
 681             CValueInner::ByRef(_, Some(_)) => todo!(),
 682         }
 683     }
 684
 685     pub(crate) fn place_field(
 686         self,
 687         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 688         field: mir::Field,
 689     ) -> CPlace<'tcx> {
 690         let layout = self.layout();
 691
 692         match self.inner {
 693             CPlaceInner::Var(local, var) => {
 694                 if let Abi::Vector { .. } = layout.abi {
 695                     return CPlace {
 696                         inner: CPlaceInner::VarLane(local, var, field.as_u32().try_into().unwrap()),
 697                         layout: layout.field(fx, field.as_u32().try_into().unwrap()),
 698                     };
 699                 }
 700             }
 701             CPlaceInner::VarPair(local, var1, var2) => {
 702                 let layout = layout.field(&*fx, field.index());
 703
 704                 match field.as_u32() {
 705                     0 => {
 706                         return CPlace {
 707                             inner: CPlaceInner::Var(local, var1),
 708                             layout,
 709                         }
 710                     }
 711                     1 => {
 712                         return CPlace {
 713                             inner: CPlaceInner::Var(local, var2),
 714                             layout,
 715                         }
 716                     }
 717                     _ => unreachable!("field should be 0 or 1"),
 718                 }
 719             }
 720             _ => {}
 721         }
 722
 723         let (base, extra) = self.to_ptr_maybe_unsized();
 724
 725         let (field_ptr, field_layout) = codegen_field(fx, base, extra, layout, field);
 726         if field_layout.is_unsized() {
 727             CPlace::for_ptr_with_extra(field_ptr, extra.unwrap(), field_layout)
 728         } else {
 729             CPlace::for_ptr(field_ptr, field_layout)
 730         }
 731     }
 732
 733     pub(crate) fn place_index(
 734         self,
 735         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 736         index: Value,
 737     ) -> CPlace<'tcx> {
 738         let (elem_layout, ptr) = match self.layout().ty.kind() {
 739             ty::Array(elem_ty, _) => (fx.layout_of(elem_ty), self.to_ptr()),
 740             ty::Slice(elem_ty) => (fx.layout_of(elem_ty), self.to_ptr_maybe_unsized().0),
 741             _ => bug!("place_index({:?})", self.layout().ty),
 742         };
 743
 744         let offset = fx
 745             .bcx
 746             .ins()
 747             .imul_imm(index, elem_layout.size.bytes() as i64);
 748
 749         CPlace::for_ptr(ptr.offset_value(fx, offset), elem_layout)
 750     }
 751
 752     pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, 'tcx, impl Module>) -> CPlace<'tcx> {
 753         let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap().ty);
 754         if has_ptr_meta(fx.tcx, inner_layout.ty) {
 755             let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx);
 756             CPlace::for_ptr_with_extra(Pointer::new(addr), extra, inner_layout)
 757         } else {
 758             CPlace::for_ptr(
 759                 Pointer::new(self.to_cvalue(fx).load_scalar(fx)),
 760                 inner_layout,
 761             )
 762         }
 763     }
 764
 765     pub(crate) fn place_ref(
 766         self,
 767         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 768         layout: TyAndLayout<'tcx>,
 769     ) -> CValue<'tcx> {
 770         if has_ptr_meta(fx.tcx, self.layout().ty) {
 771             let (ptr, extra) = self.to_ptr_maybe_unsized();
 772             CValue::by_val_pair(
 773                 ptr.get_addr(fx),
 774                 extra.expect("unsized type without metadata"),
 775                 layout,
 776             )
 777         } else {
 778             CValue::by_val(self.to_ptr().get_addr(fx), layout)
 779         }
 780     }
 781
 782     pub(crate) fn downcast_variant(
 783         self,
 784         fx: &FunctionCx<'_, 'tcx, impl Module>,
 785         variant: VariantIdx,
 786     ) -> Self {
 787         assert!(!self.layout().is_unsized());
 788         let layout = self.layout().for_variant(fx, variant);
 789         CPlace {
 790             inner: self.inner,
 791             layout,
 792         }
 793     }
 794 }