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                     for (from, to) in from_traits.iter().zip(to_traits) {
 484                         let from = fx
 485                             .tcx
 486                             .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), from);
 487                         let to = fx
 488                             .tcx
 489                             .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), to);
 490                         assert_eq!(
 491                             from, to,
 492                             "Can't write trait object of incompatible traits {:?} to place with traits {:?}\n\n{:#?}",
 493                             from_traits, to_traits, fx,
 494                         );
 495                     }
 496                     // dyn for<'r> Trait<'r> -> dyn Trait<'_> is allowed
 497                 }
 498                 _ => {
 499                     assert_eq!(
 500                         from_ty,
 501                         to_ty,
 502                         "Can't write value with incompatible type {:?} to place with type {:?}\n\n{:#?}",
 503                         from_ty,
 504                         to_ty,
 505                         fx,
 506                     );
 507                 }
 508             }
 509         }
 510
 511         assert_assignable(fx, from.layout().ty, self.layout().ty);
 512
 513         self.write_cvalue_maybe_transmute(fx, from, "write_cvalue");
 514     }
 515
 516     pub(crate) fn write_cvalue_transmute(
 517         self,
 518         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 519         from: CValue<'tcx>,
 520     ) {
 521         self.write_cvalue_maybe_transmute(fx, from, "write_cvalue_transmute");
 522     }
 523
 524     fn write_cvalue_maybe_transmute(
 525         self,
 526         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 527         from: CValue<'tcx>,
 528         #[cfg_attr(not(debug_assertions), allow(unused_variables))] method: &'static str,
 529     ) {
 530         fn transmute_value<'tcx>(
 531             fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 532             var: Variable,
 533             data: Value,
 534             dst_ty: Type,
 535         ) {
 536             let src_ty = fx.bcx.func.dfg.value_type(data);
 537             assert_eq!(
 538                 src_ty.bytes(),
 539                 dst_ty.bytes(),
 540                 "write_cvalue_transmute: {:?} -> {:?}",
 541                 src_ty,
 542                 dst_ty,
 543             );
 544             let data = match (src_ty, dst_ty) {
 545                 (_, _) if src_ty == dst_ty => data,
 546
 547                 // This is a `write_cvalue_transmute`.
 548                 (types::I32, types::F32)
 549                 | (types::F32, types::I32)
 550                 | (types::I64, types::F64)
 551                 | (types::F64, types::I64) => fx.bcx.ins().bitcast(dst_ty, data),
 552                 _ if src_ty.is_vector() && dst_ty.is_vector() => {
 553                     fx.bcx.ins().raw_bitcast(dst_ty, data)
 554                 }
 555                 _ if src_ty.is_vector() || dst_ty.is_vector() => {
 556                     // FIXME do something more efficient for transmutes between vectors and integers.
 557                     let stack_slot = fx.bcx.create_stack_slot(StackSlotData {
 558                         kind: StackSlotKind::ExplicitSlot,
 559                         size: src_ty.bytes(),
 560                         offset: None,
 561                     });
 562                     let ptr = Pointer::stack_slot(stack_slot);
 563                     ptr.store(fx, data, MemFlags::trusted());
 564                     ptr.load(fx, dst_ty, MemFlags::trusted())
 565                 }
 566                 _ => unreachable!("write_cvalue_transmute: {:?} -> {:?}", src_ty, dst_ty),
 567             };
 568             fx.bcx
 569                 .set_val_label(data, cranelift_codegen::ir::ValueLabel::new(var.index()));
 570             fx.bcx.def_var(var, data);
 571         }
 572
 573         assert_eq!(self.layout().size, from.layout().size);
 574
 575         #[cfg(debug_assertions)]
 576         {
 577             use cranelift_codegen::cursor::{Cursor, CursorPosition};
 578             let cur_block = match fx.bcx.cursor().position() {
 579                 CursorPosition::After(block) => block,
 580                 _ => unreachable!(),
 581             };
 582             fx.add_comment(
 583                 fx.bcx.func.layout.last_inst(cur_block).unwrap(),
 584                 format!(
 585                     "{}: {:?}: {:?} <- {:?}: {:?}",
 586                     method,
 587                     self.inner(),
 588                     self.layout().ty,
 589                     from.0,
 590                     from.layout().ty
 591                 ),
 592             );
 593         }
 594
 595         let dst_layout = self.layout();
 596         let to_ptr = match self.inner {
 597             CPlaceInner::Var(_local, var) => {
 598                 let data = CValue(from.0, dst_layout).load_scalar(fx);
 599                 let dst_ty = fx.clif_type(self.layout().ty).unwrap();
 600                 transmute_value(fx, var, data, dst_ty);
 601                 return;
 602             }
 603             CPlaceInner::VarPair(_local, var1, var2) => {
 604                 let (data1, data2) = CValue(from.0, dst_layout).load_scalar_pair(fx);
 605                 let (dst_ty1, dst_ty2) = fx.clif_pair_type(self.layout().ty).unwrap();
 606                 transmute_value(fx, var1, data1, dst_ty1);
 607                 transmute_value(fx, var2, data2, dst_ty2);
 608                 return;
 609             }
 610             CPlaceInner::VarLane(_local, var, lane) => {
 611                 let data = from.load_scalar(fx);
 612
 613                 // First get the old vector
 614                 let vector = fx.bcx.use_var(var);
 615                 fx.bcx
 616                     .set_val_label(vector, cranelift_codegen::ir::ValueLabel::new(var.index()));
 617
 618                 // Next insert the written lane into the vector
 619                 let vector = fx.bcx.ins().insertlane(vector, data, lane);
 620
 621                 // Finally write the new vector
 622                 fx.bcx
 623                     .set_val_label(vector, cranelift_codegen::ir::ValueLabel::new(var.index()));
 624                 fx.bcx.def_var(var, vector);
 625
 626                 return;
 627             }
 628             CPlaceInner::Addr(ptr, None) => {
 629                 if dst_layout.size == Size::ZERO || dst_layout.abi == Abi::Uninhabited {
 630                     return;
 631                 }
 632                 ptr
 633             }
 634             CPlaceInner::Addr(_, Some(_)) => bug!("Can't write value to unsized place {:?}", self),
 635         };
 636
 637         let mut flags = MemFlags::new();
 638         flags.set_notrap();
 639         match from.layout().abi {
 640             // FIXME make Abi::Vector work too
 641             Abi::Scalar(_) => {
 642                 let val = from.load_scalar(fx);
 643                 to_ptr.store(fx, val, flags);
 644                 return;
 645             }
 646             Abi::ScalarPair(ref a_scalar, ref b_scalar) => {
 647                 let (value, extra) = from.load_scalar_pair(fx);
 648                 let b_offset = scalar_pair_calculate_b_offset(fx.tcx, a_scalar, b_scalar);
 649                 to_ptr.store(fx, value, flags);
 650                 to_ptr.offset(fx, b_offset).store(fx, extra, flags);
 651                 return;
 652             }
 653             _ => {}
 654         }
 655
 656         match from.0 {
 657             CValueInner::ByVal(val) => {
 658                 to_ptr.store(fx, val, flags);
 659             }
 660             CValueInner::ByValPair(_, _) => {
 661                 bug!(
 662                     "Non ScalarPair abi {:?} for ByValPair CValue",
 663                     dst_layout.abi
 664                 );
 665             }
 666             CValueInner::ByRef(from_ptr, None) => {
 667                 let from_addr = from_ptr.get_addr(fx);
 668                 let to_addr = to_ptr.get_addr(fx);
 669                 let src_layout = from.1;
 670                 let size = dst_layout.size.bytes();
 671                 let src_align = src_layout.align.abi.bytes() as u8;
 672                 let dst_align = dst_layout.align.abi.bytes() as u8;
 673                 fx.bcx.emit_small_memory_copy(
 674                     fx.cx.module.target_config(),
 675                     to_addr,
 676                     from_addr,
 677                     size,
 678                     dst_align,
 679                     src_align,
 680                     true,
 681                 );
 682             }
 683             CValueInner::ByRef(_, Some(_)) => todo!(),
 684         }
 685     }
 686
 687     pub(crate) fn place_field(
 688         self,
 689         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 690         field: mir::Field,
 691     ) -> CPlace<'tcx> {
 692         let layout = self.layout();
 693
 694         match self.inner {
 695             CPlaceInner::Var(local, var) => {
 696                 if let Abi::Vector { .. } = layout.abi {
 697                     return CPlace {
 698                         inner: CPlaceInner::VarLane(local, var, field.as_u32().try_into().unwrap()),
 699                         layout: layout.field(fx, field.as_u32().try_into().unwrap()),
 700                     };
 701                 }
 702             }
 703             CPlaceInner::VarPair(local, var1, var2) => {
 704                 let layout = layout.field(&*fx, field.index());
 705
 706                 match field.as_u32() {
 707                     0 => {
 708                         return CPlace {
 709                             inner: CPlaceInner::Var(local, var1),
 710                             layout,
 711                         }
 712                     }
 713                     1 => {
 714                         return CPlace {
 715                             inner: CPlaceInner::Var(local, var2),
 716                             layout,
 717                         }
 718                     }
 719                     _ => unreachable!("field should be 0 or 1"),
 720                 }
 721             }
 722             _ => {}
 723         }
 724
 725         let (base, extra) = self.to_ptr_maybe_unsized();
 726
 727         let (field_ptr, field_layout) = codegen_field(fx, base, extra, layout, field);
 728         if field_layout.is_unsized() {
 729             CPlace::for_ptr_with_extra(field_ptr, extra.unwrap(), field_layout)
 730         } else {
 731             CPlace::for_ptr(field_ptr, field_layout)
 732         }
 733     }
 734
 735     pub(crate) fn place_index(
 736         self,
 737         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 738         index: Value,
 739     ) -> CPlace<'tcx> {
 740         let (elem_layout, ptr) = match self.layout().ty.kind() {
 741             ty::Array(elem_ty, _) => (fx.layout_of(elem_ty), self.to_ptr()),
 742             ty::Slice(elem_ty) => (fx.layout_of(elem_ty), self.to_ptr_maybe_unsized().0),
 743             _ => bug!("place_index({:?})", self.layout().ty),
 744         };
 745
 746         let offset = fx
 747             .bcx
 748             .ins()
 749             .imul_imm(index, elem_layout.size.bytes() as i64);
 750
 751         CPlace::for_ptr(ptr.offset_value(fx, offset), elem_layout)
 752     }
 753
 754     pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, 'tcx, impl Module>) -> CPlace<'tcx> {
 755         let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap().ty);
 756         if has_ptr_meta(fx.tcx, inner_layout.ty) {
 757             let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx);
 758             CPlace::for_ptr_with_extra(Pointer::new(addr), extra, inner_layout)
 759         } else {
 760             CPlace::for_ptr(
 761                 Pointer::new(self.to_cvalue(fx).load_scalar(fx)),
 762                 inner_layout,
 763             )
 764         }
 765     }
 766
 767     pub(crate) fn place_ref(
 768         self,
 769         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 770         layout: TyAndLayout<'tcx>,
 771     ) -> CValue<'tcx> {
 772         if has_ptr_meta(fx.tcx, self.layout().ty) {
 773             let (ptr, extra) = self.to_ptr_maybe_unsized();
 774             CValue::by_val_pair(
 775                 ptr.get_addr(fx),
 776                 extra.expect("unsized type without metadata"),
 777                 layout,
 778             )
 779         } else {
 780             CValue::by_val(self.to_ptr().get_addr(fx), layout)
 781         }
 782     }
 783
 784     pub(crate) fn downcast_variant(
 785         self,
 786         fx: &FunctionCx<'_, 'tcx, impl Module>,
 787         variant: VariantIdx,
 788     ) -> Self {
 789         assert!(!self.layout().is_unsized());
 790         let layout = self.layout().for_variant(fx, variant);
 791         CPlace {
 792             inner: self.inner,
 793             layout,
 794         }
 795     }
 796 }