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