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(..) => return simple(fx),
  31             ty::Adt(def, _) if def.repr.packed() => {
  32                 assert_eq!(layout.align.abi.bytes(), 1);
  33                 return 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: u128,
 235     ) -> CValue<'tcx> {
 236         use cranelift_codegen::ir::immediates::{Ieee32, Ieee64};
 237
 238         let clif_ty = fx.clif_type(layout.ty).unwrap();
 239
 240         match layout.ty.kind() {
 241             ty::Bool => {
 242                 assert!(
 243                     const_val == 0 || const_val == 1,
 244                     "Invalid bool 0x{:032X}",
 245                     const_val
 246                 );
 247             }
 248             _ => {}
 249         }
 250
 251         let val = match layout.ty.kind() {
 252             ty::Uint(UintTy::U128) | ty::Int(IntTy::I128) => {
 253                 let lsb = fx.bcx.ins().iconst(types::I64, const_val as u64 as i64);
 254                 let msb = fx
 255                     .bcx
 256                     .ins()
 257                     .iconst(types::I64, (const_val >> 64) as u64 as i64);
 258                 fx.bcx.ins().iconcat(lsb, msb)
 259             }
 260             ty::Bool | ty::Char | ty::Uint(_) | ty::Int(_) | ty::Ref(..)
 261             | ty::RawPtr(..) => {
 262                 fx
 263                     .bcx
 264                     .ins()
 265                     .iconst(clif_ty, u64::try_from(const_val).expect("uint") as i64)
 266             }
 267             ty::Float(FloatTy::F32) => {
 268                 fx.bcx.ins().f32const(Ieee32::with_bits(u32::try_from(const_val).unwrap()))
 269             }
 270             ty::Float(FloatTy::F64) => {
 271                 fx.bcx.ins().f64const(Ieee64::with_bits(u64::try_from(const_val).unwrap()))
 272             }
 273             _ => panic!(
 274                 "CValue::const_val for non bool/char/float/integer/pointer type {:?} is not allowed",
 275                 layout.ty
 276             ),
 277         };
 278
 279         CValue::by_val(val, layout)
 280     }
 281
 282     pub(crate) fn cast_pointer_to(self, layout: TyAndLayout<'tcx>) -> Self {
 283         assert!(matches!(
 284             self.layout().ty.kind(),
 285             ty::Ref(..) | ty::RawPtr(..) | ty::FnPtr(..)
 286         ));
 287         assert!(matches!(
 288             layout.ty.kind(),
 289             ty::Ref(..) | ty::RawPtr(..) | ty::FnPtr(..)
 290         ));
 291         assert_eq!(self.layout().abi, layout.abi);
 292         CValue(self.0, layout)
 293     }
 294 }
 295
 296 /// A place where you can write a value to or read a value from
 297 #[derive(Debug, Copy, Clone)]
 298 pub(crate) struct CPlace<'tcx> {
 299     inner: CPlaceInner,
 300     layout: TyAndLayout<'tcx>,
 301 }
 302
 303 #[derive(Debug, Copy, Clone)]
 304 pub(crate) enum CPlaceInner {
 305     Var(Local, Variable),
 306     VarPair(Local, Variable, Variable),
 307     VarLane(Local, Variable, u8),
 308     Addr(Pointer, Option<Value>),
 309 }
 310
 311 impl<'tcx> CPlace<'tcx> {
 312     pub(crate) fn layout(&self) -> TyAndLayout<'tcx> {
 313         self.layout
 314     }
 315
 316     pub(crate) fn inner(&self) -> &CPlaceInner {
 317         &self.inner
 318     }
 319
 320     pub(crate) fn no_place(layout: TyAndLayout<'tcx>) -> CPlace<'tcx> {
 321         CPlace {
 322             inner: CPlaceInner::Addr(Pointer::dangling(layout.align.pref), None),
 323             layout,
 324         }
 325     }
 326
 327     pub(crate) fn new_stack_slot(
 328         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 329         layout: TyAndLayout<'tcx>,
 330     ) -> CPlace<'tcx> {
 331         assert!(!layout.is_unsized());
 332         if layout.size.bytes() == 0 {
 333             return CPlace::no_place(layout);
 334         }
 335
 336         let stack_slot = fx.bcx.create_stack_slot(StackSlotData {
 337             kind: StackSlotKind::ExplicitSlot,
 338             size: layout.size.bytes() as u32,
 339             offset: None,
 340         });
 341         CPlace {
 342             inner: CPlaceInner::Addr(Pointer::stack_slot(stack_slot), None),
 343             layout,
 344         }
 345     }
 346
 347     pub(crate) fn new_var(
 348         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 349         local: Local,
 350         layout: TyAndLayout<'tcx>,
 351     ) -> CPlace<'tcx> {
 352         let var = Variable::with_u32(fx.next_ssa_var);
 353         fx.next_ssa_var += 1;
 354         fx.bcx.declare_var(var, fx.clif_type(layout.ty).unwrap());
 355         CPlace {
 356             inner: CPlaceInner::Var(local, var),
 357             layout,
 358         }
 359     }
 360
 361     pub(crate) fn new_var_pair(
 362         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 363         local: Local,
 364         layout: TyAndLayout<'tcx>,
 365     ) -> CPlace<'tcx> {
 366         let var1 = Variable::with_u32(fx.next_ssa_var);
 367         fx.next_ssa_var += 1;
 368         let var2 = Variable::with_u32(fx.next_ssa_var);
 369         fx.next_ssa_var += 1;
 370
 371         let (ty1, ty2) = fx.clif_pair_type(layout.ty).unwrap();
 372         fx.bcx.declare_var(var1, ty1);
 373         fx.bcx.declare_var(var2, ty2);
 374         CPlace {
 375             inner: CPlaceInner::VarPair(local, var1, var2),
 376             layout,
 377         }
 378     }
 379
 380     pub(crate) fn for_ptr(ptr: Pointer, layout: TyAndLayout<'tcx>) -> CPlace<'tcx> {
 381         CPlace {
 382             inner: CPlaceInner::Addr(ptr, None),
 383             layout,
 384         }
 385     }
 386
 387     pub(crate) fn for_ptr_with_extra(
 388         ptr: Pointer,
 389         extra: Value,
 390         layout: TyAndLayout<'tcx>,
 391     ) -> CPlace<'tcx> {
 392         CPlace {
 393             inner: CPlaceInner::Addr(ptr, Some(extra)),
 394             layout,
 395         }
 396     }
 397
 398     pub(crate) fn to_cvalue(self, fx: &mut FunctionCx<'_, 'tcx, impl Module>) -> CValue<'tcx> {
 399         let layout = self.layout();
 400         match self.inner {
 401             CPlaceInner::Var(_local, var) => {
 402                 let val = fx.bcx.use_var(var);
 403                 fx.bcx
 404                     .set_val_label(val, cranelift_codegen::ir::ValueLabel::new(var.index()));
 405                 CValue::by_val(val, layout)
 406             }
 407             CPlaceInner::VarPair(_local, var1, var2) => {
 408                 let val1 = fx.bcx.use_var(var1);
 409                 fx.bcx
 410                     .set_val_label(val1, cranelift_codegen::ir::ValueLabel::new(var1.index()));
 411                 let val2 = fx.bcx.use_var(var2);
 412                 fx.bcx
 413                     .set_val_label(val2, cranelift_codegen::ir::ValueLabel::new(var2.index()));
 414                 CValue::by_val_pair(val1, val2, layout)
 415             }
 416             CPlaceInner::VarLane(_local, var, lane) => {
 417                 let val = fx.bcx.use_var(var);
 418                 fx.bcx
 419                     .set_val_label(val, cranelift_codegen::ir::ValueLabel::new(var.index()));
 420                 let val = fx.bcx.ins().extractlane(val, lane);
 421                 CValue::by_val(val, layout)
 422             }
 423             CPlaceInner::Addr(ptr, extra) => {
 424                 if let Some(extra) = extra {
 425                     CValue::by_ref_unsized(ptr, extra, layout)
 426                 } else {
 427                     CValue::by_ref(ptr, layout)
 428                 }
 429             }
 430         }
 431     }
 432
 433     pub(crate) fn to_ptr(self) -> Pointer {
 434         match self.to_ptr_maybe_unsized() {
 435             (ptr, None) => ptr,
 436             (_, Some(_)) => bug!("Expected sized cplace, found {:?}", self),
 437         }
 438     }
 439
 440     pub(crate) fn to_ptr_maybe_unsized(self) -> (Pointer, Option<Value>) {
 441         match self.inner {
 442             CPlaceInner::Addr(ptr, extra) => (ptr, extra),
 443             CPlaceInner::Var(_, _)
 444             | CPlaceInner::VarPair(_, _, _)
 445             | CPlaceInner::VarLane(_, _, _) => bug!("Expected CPlace::Addr, found {:?}", self),
 446         }
 447     }
 448
 449     pub(crate) fn write_cvalue(
 450         self,
 451         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 452         from: CValue<'tcx>,
 453     ) {
 454         fn assert_assignable<'tcx>(
 455             fx: &FunctionCx<'_, 'tcx, impl Module>,
 456             from_ty: Ty<'tcx>,
 457             to_ty: Ty<'tcx>,
 458         ) {
 459             match (&from_ty.kind(), &to_ty.kind()) {
 460                 (ty::Ref(_, a, _), ty::Ref(_, b, _))
 461                 | (
 462                     ty::RawPtr(TypeAndMut { ty: a, mutbl: _ }),
 463                     ty::RawPtr(TypeAndMut { ty: b, mutbl: _ }),
 464                 ) => {
 465                     assert_assignable(fx, a, b);
 466                 }
 467                 (ty::FnPtr(_), ty::FnPtr(_)) => {
 468                     let from_sig = fx.tcx.normalize_erasing_late_bound_regions(
 469                         ParamEnv::reveal_all(),
 470                         &from_ty.fn_sig(fx.tcx),
 471                     );
 472                     let to_sig = fx.tcx.normalize_erasing_late_bound_regions(
 473                         ParamEnv::reveal_all(),
 474                         &to_ty.fn_sig(fx.tcx),
 475                     );
 476                     assert_eq!(
 477                         from_sig, to_sig,
 478                         "Can't write fn ptr with incompatible sig {:?} to place with sig {:?}\n\n{:#?}",
 479                         from_sig, to_sig, fx,
 480                     );
 481                     // fn(&T) -> for<'l> fn(&'l T) is allowed
 482                 }
 483                 (ty::Dynamic(from_traits, _), ty::Dynamic(to_traits, _)) => {
 484                     let from_traits = fx
 485                         .tcx
 486                         .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), from_traits);
 487                     let to_traits = fx
 488                         .tcx
 489                         .normalize_erasing_late_bound_regions(ParamEnv::reveal_all(), to_traits);
 490                     assert_eq!(
 491                         from_traits, to_traits,
 492                         "Can't write trait object of incompatible traits {:?} to place with traits {:?}\n\n{:#?}",
 493                         from_traits, to_traits, fx,
 494                     );
 495                     // dyn for<'r> Trait<'r> -> dyn Trait<'_> is allowed
 496                 }
 497                 _ => {
 498                     assert_eq!(
 499                         from_ty,
 500                         to_ty,
 501                         "Can't write value with incompatible type {:?} to place with type {:?}\n\n{:#?}",
 502                         from_ty,
 503                         to_ty,
 504                         fx,
 505                     );
 506                 }
 507             }
 508         }
 509
 510         assert_assignable(fx, from.layout().ty, self.layout().ty);
 511
 512         self.write_cvalue_maybe_transmute(fx, from, "write_cvalue");
 513     }
 514
 515     pub(crate) fn write_cvalue_transmute(
 516         self,
 517         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 518         from: CValue<'tcx>,
 519     ) {
 520         self.write_cvalue_maybe_transmute(fx, from, "write_cvalue_transmute");
 521     }
 522
 523     fn write_cvalue_maybe_transmute(
 524         self,
 525         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 526         from: CValue<'tcx>,
 527         #[cfg_attr(not(debug_assertions), allow(unused_variables))] method: &'static str,
 528     ) {
 529         fn transmute_value<'tcx>(
 530             fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 531             var: Variable,
 532             data: Value,
 533             dst_ty: Type,
 534         ) {
 535             let src_ty = fx.bcx.func.dfg.value_type(data);
 536             let data = match (src_ty, dst_ty) {
 537                 (_, _) if src_ty == dst_ty => data,
 538
 539                 // This is a `write_cvalue_transmute`.
 540                 (types::I32, types::F32)
 541                 | (types::F32, types::I32)
 542                 | (types::I64, types::F64)
 543                 | (types::F64, types::I64) => fx.bcx.ins().bitcast(dst_ty, data),
 544                 _ if src_ty.is_vector() && dst_ty.is_vector() => {
 545                     fx.bcx.ins().raw_bitcast(dst_ty, data)
 546                 }
 547                 _ => unreachable!("write_cvalue_transmute: {:?} -> {:?}", src_ty, dst_ty),
 548             };
 549             fx.bcx
 550                 .set_val_label(data, cranelift_codegen::ir::ValueLabel::new(var.index()));
 551             fx.bcx.def_var(var, data);
 552         }
 553
 554         assert_eq!(self.layout().size, from.layout().size);
 555
 556         #[cfg(debug_assertions)]
 557         {
 558             use cranelift_codegen::cursor::{Cursor, CursorPosition};
 559             let cur_block = match fx.bcx.cursor().position() {
 560                 CursorPosition::After(block) => block,
 561                 _ => unreachable!(),
 562             };
 563             fx.add_comment(
 564                 fx.bcx.func.layout.last_inst(cur_block).unwrap(),
 565                 format!(
 566                     "{}: {:?}: {:?} <- {:?}: {:?}",
 567                     method,
 568                     self.inner(),
 569                     self.layout().ty,
 570                     from.0,
 571                     from.layout().ty
 572                 ),
 573             );
 574         }
 575
 576         let dst_layout = self.layout();
 577         let to_ptr = match self.inner {
 578             CPlaceInner::Var(_local, var) => {
 579                 let data = CValue(from.0, dst_layout).load_scalar(fx);
 580                 let dst_ty = fx.clif_type(self.layout().ty).unwrap();
 581                 transmute_value(fx, var, data, dst_ty);
 582                 return;
 583             }
 584             CPlaceInner::VarPair(_local, var1, var2) => {
 585                 let (data1, data2) = CValue(from.0, dst_layout).load_scalar_pair(fx);
 586                 let (dst_ty1, dst_ty2) = fx.clif_pair_type(self.layout().ty).unwrap();
 587                 transmute_value(fx, var1, data1, dst_ty1);
 588                 transmute_value(fx, var2, data2, dst_ty2);
 589                 return;
 590             }
 591             CPlaceInner::VarLane(_local, var, lane) => {
 592                 let data = from.load_scalar(fx);
 593
 594                 // First get the old vector
 595                 let vector = fx.bcx.use_var(var);
 596                 fx.bcx
 597                     .set_val_label(vector, cranelift_codegen::ir::ValueLabel::new(var.index()));
 598
 599                 // Next insert the written lane into the vector
 600                 let vector = fx.bcx.ins().insertlane(vector, data, lane);
 601
 602                 // Finally write the new vector
 603                 fx.bcx
 604                     .set_val_label(vector, cranelift_codegen::ir::ValueLabel::new(var.index()));
 605                 fx.bcx.def_var(var, vector);
 606
 607                 return;
 608             }
 609             CPlaceInner::Addr(ptr, None) => {
 610                 if dst_layout.size == Size::ZERO || dst_layout.abi == Abi::Uninhabited {
 611                     return;
 612                 }
 613                 ptr
 614             }
 615             CPlaceInner::Addr(_, Some(_)) => bug!("Can't write value to unsized place {:?}", self),
 616         };
 617
 618         let mut flags = MemFlags::new();
 619         flags.set_notrap();
 620         match from.layout().abi {
 621             // FIXME make Abi::Vector work too
 622             Abi::Scalar(_) => {
 623                 let val = from.load_scalar(fx);
 624                 to_ptr.store(fx, val, flags);
 625                 return;
 626             }
 627             Abi::ScalarPair(ref a_scalar, ref b_scalar) => {
 628                 let (value, extra) = from.load_scalar_pair(fx);
 629                 let b_offset = scalar_pair_calculate_b_offset(fx.tcx, a_scalar, b_scalar);
 630                 to_ptr.store(fx, value, flags);
 631                 to_ptr.offset(fx, b_offset).store(fx, extra, flags);
 632                 return;
 633             }
 634             _ => {}
 635         }
 636
 637         match from.0 {
 638             CValueInner::ByVal(val) => {
 639                 to_ptr.store(fx, val, flags);
 640             }
 641             CValueInner::ByValPair(_, _) => {
 642                 bug!(
 643                     "Non ScalarPair abi {:?} for ByValPair CValue",
 644                     dst_layout.abi
 645                 );
 646             }
 647             CValueInner::ByRef(from_ptr, None) => {
 648                 let from_addr = from_ptr.get_addr(fx);
 649                 let to_addr = to_ptr.get_addr(fx);
 650                 let src_layout = from.1;
 651                 let size = dst_layout.size.bytes();
 652                 let src_align = src_layout.align.abi.bytes() as u8;
 653                 let dst_align = dst_layout.align.abi.bytes() as u8;
 654                 fx.bcx.emit_small_memory_copy(
 655                     fx.cx.module.target_config(),
 656                     to_addr,
 657                     from_addr,
 658                     size,
 659                     dst_align,
 660                     src_align,
 661                     true,
 662                 );
 663             }
 664             CValueInner::ByRef(_, Some(_)) => todo!(),
 665         }
 666     }
 667
 668     pub(crate) fn place_field(
 669         self,
 670         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 671         field: mir::Field,
 672     ) -> CPlace<'tcx> {
 673         let layout = self.layout();
 674
 675         match self.inner {
 676             CPlaceInner::Var(local, var) => {
 677                 if let Abi::Vector { .. } = layout.abi {
 678                     return CPlace {
 679                         inner: CPlaceInner::VarLane(local, var, field.as_u32().try_into().unwrap()),
 680                         layout: layout.field(fx, field.as_u32().try_into().unwrap()),
 681                     };
 682                 }
 683             }
 684             CPlaceInner::VarPair(local, var1, var2) => {
 685                 let layout = layout.field(&*fx, field.index());
 686
 687                 match field.as_u32() {
 688                     0 => {
 689                         return CPlace {
 690                             inner: CPlaceInner::Var(local, var1),
 691                             layout,
 692                         }
 693                     }
 694                     1 => {
 695                         return CPlace {
 696                             inner: CPlaceInner::Var(local, var2),
 697                             layout,
 698                         }
 699                     }
 700                     _ => unreachable!("field should be 0 or 1"),
 701                 }
 702             }
 703             _ => {}
 704         }
 705
 706         let (base, extra) = self.to_ptr_maybe_unsized();
 707
 708         let (field_ptr, field_layout) = codegen_field(fx, base, extra, layout, field);
 709         if field_layout.is_unsized() {
 710             CPlace::for_ptr_with_extra(field_ptr, extra.unwrap(), field_layout)
 711         } else {
 712             CPlace::for_ptr(field_ptr, field_layout)
 713         }
 714     }
 715
 716     pub(crate) fn place_index(
 717         self,
 718         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 719         index: Value,
 720     ) -> CPlace<'tcx> {
 721         let (elem_layout, ptr) = match self.layout().ty.kind() {
 722             ty::Array(elem_ty, _) => (fx.layout_of(elem_ty), self.to_ptr()),
 723             ty::Slice(elem_ty) => (fx.layout_of(elem_ty), self.to_ptr_maybe_unsized().0),
 724             _ => bug!("place_index({:?})", self.layout().ty),
 725         };
 726
 727         let offset = fx
 728             .bcx
 729             .ins()
 730             .imul_imm(index, elem_layout.size.bytes() as i64);
 731
 732         CPlace::for_ptr(ptr.offset_value(fx, offset), elem_layout)
 733     }
 734
 735     pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, 'tcx, impl Module>) -> CPlace<'tcx> {
 736         let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap().ty);
 737         if has_ptr_meta(fx.tcx, inner_layout.ty) {
 738             let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx);
 739             CPlace::for_ptr_with_extra(Pointer::new(addr), extra, inner_layout)
 740         } else {
 741             CPlace::for_ptr(
 742                 Pointer::new(self.to_cvalue(fx).load_scalar(fx)),
 743                 inner_layout,
 744             )
 745         }
 746     }
 747
 748     pub(crate) fn place_ref(
 749         self,
 750         fx: &mut FunctionCx<'_, 'tcx, impl Module>,
 751         layout: TyAndLayout<'tcx>,
 752     ) -> CValue<'tcx> {
 753         if has_ptr_meta(fx.tcx, self.layout().ty) {
 754             let (ptr, extra) = self.to_ptr_maybe_unsized();
 755             CValue::by_val_pair(
 756                 ptr.get_addr(fx),
 757                 extra.expect("unsized type without metadata"),
 758                 layout,
 759             )
 760         } else {
 761             CValue::by_val(self.to_ptr().get_addr(fx), layout)
 762         }
 763     }
 764
 765     pub(crate) fn downcast_variant(
 766         self,
 767         fx: &FunctionCx<'_, 'tcx, impl Module>,
 768         variant: VariantIdx,
 769     ) -> Self {
 770         assert!(!self.layout().is_unsized());
 771         let layout = self.layout().for_variant(fx, variant);
 772         CPlace {
 773             inner: self.inner,
 774             layout,
 775         }
 776     }
 777 }