Allow unsized types as function parameters

bjorn3 · bjorn3 · commit 9cfb9470c529 · 2020-01-25T16:23:54.000+01:00
diff --git a/src/abi/comments.rs b/src/abi/comments.rs
@@ -77,15 +77,21 @@ pub fn add_local_place_comments<'tcx>(
             ("ssa", std::borrow::Cow::Borrowed(""))
         }
         CPlaceInner::NoPlace => ("zst", "".into()),
-        CPlaceInner::Addr(ptr, None) => match ptr.base_and_offset() {
-            (crate::pointer::PointerBase::Addr(addr), offset) => {
-                ("reuse", format!("storage={}{}", addr, offset).into())
+        CPlaceInner::Addr(ptr, meta) => {
+            let meta = if let Some(meta) = meta {
+                Cow::Owned(format!(",meta={}", meta))
+            } else {
+                Cow::Borrowed("")
+            };
+            match ptr.base_and_offset() {
+                (crate::pointer::PointerBase::Addr(addr), offset) => {
+                    ("reuse", format!("storage={}{}{}", addr, offset, meta).into())
+                }
+                (crate::pointer::PointerBase::Stack(stack_slot), offset) => {
+                    ("stack", format!("storage={}{}{}", stack_slot, offset, meta).into())
+                }
             }
-            (crate::pointer::PointerBase::Stack(stack_slot), offset) => {
-                ("stack", format!("storage={}{}", stack_slot, offset).into())
-            }
-        },
-        CPlaceInner::Addr(_, Some(_)) => unreachable!(),
+        }
     };
 
     fx.add_global_comment(format!(
diff --git a/src/abi/mod.rs b/src/abi/mod.rs
@@ -139,7 +139,7 @@ fn clif_sig_from_fn_sig<'tcx>(
             inputs.map(AbiParam::new).collect(),
             vec![AbiParam::new(ret_ty_a), AbiParam::new(ret_ty_b)],
         ),
-        PassMode::ByRef => {
+        PassMode::ByRef { sized: true } => {
             (
                 Some(pointer_ty(tcx)) // First param is place to put return val
                     .into_iter()
@@ -149,6 +149,7 @@ fn clif_sig_from_fn_sig<'tcx>(
                 vec![],
             )
         }
+        PassMode::ByRef { sized: false } => todo!(),
     };
 
     if requires_caller_location {
@@ -350,9 +351,11 @@ pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_ebb:
 
         let is_ssa = ssa_analyzed[local] == crate::analyze::SsaKind::Ssa;
 
+        // While this is normally an optimization to prevent an unnecessary copy when an argument is
+        // not mutated by the current function, this is necessary to support unsized arguments.
         match arg_kind {
             ArgKind::Normal(Some(val)) => {
-                if let Some(addr) = val.try_to_addr() {
+                if let Some((addr, meta)) = val.try_to_addr() {
                     let local_decl = &fx.mir.local_decls[local];
                     //                       v this ! is important
                     let internally_mutable = !val.layout().ty.is_freeze(
@@ -364,7 +367,11 @@ pub fn codegen_fn_prelude(fx: &mut FunctionCx<'_, '_, impl Backend>, start_ebb:
                         // We wont mutate this argument, so it is fine to borrow the backing storage
                         // of this argument, to prevent a copy.
 
-                        let place = CPlace::for_ptr(Pointer::new(addr), val.layout());
+                        let place = if let Some(meta) = meta {
+                            CPlace::for_ptr_with_extra(Pointer::new(addr), meta, val.layout())
+                        } else {
+                            CPlace::for_ptr(Pointer::new(addr), val.layout())
+                        };
 
                         #[cfg(debug_assertions)]
                         self::comments::add_local_place_comments(fx, place, local);
diff --git a/src/abi/pass_mode.rs b/src/abi/pass_mode.rs
@@ -7,7 +7,7 @@ pub enum PassMode {
     NoPass,
     ByVal(Type),
     ByValPair(Type, Type),
-    ByRef,
+    ByRef { sized: bool },
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -70,14 +70,13 @@ impl PassMode {
             PassMode::NoPass => Empty,
             PassMode::ByVal(clif_type) => Single(clif_type),
             PassMode::ByValPair(a, b) => Pair(a, b),
-            PassMode::ByRef => Single(pointer_ty(tcx)),
+            PassMode::ByRef { sized: true } => Single(pointer_ty(tcx)),
+            PassMode::ByRef { sized: false } => Pair(pointer_ty(tcx), pointer_ty(tcx)),
         }
     }
 }
 
 pub fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyLayout<'tcx>) -> PassMode {
-    assert!(!layout.is_unsized());
-
     if layout.is_zst() {
         // WARNING zst arguments must never be passed, as that will break CastKind::ClosureFnPointer
         PassMode::NoPass
@@ -94,16 +93,16 @@ pub fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyLayout<'tcx>) -> PassMod
                     // Returning (i128, i128) by-val-pair would take 4 regs, while only 3 are
                     // available on x86_64. Cranelift gets confused when too many return params
                     // are used.
-                    PassMode::ByRef
+                    PassMode::ByRef { sized: true }
                 } else {
                     PassMode::ByValPair(a, b)
                 }
             }
 
             // FIXME implement Vector Abi in a cg_llvm compatible way
-            layout::Abi::Vector { .. } => PassMode::ByRef,
+            layout::Abi::Vector { .. } => PassMode::ByRef { sized: true },
 
-            layout::Abi::Aggregate { .. } => PassMode::ByRef,
+            &layout::Abi::Aggregate { sized } => PassMode::ByRef { sized },
         }
     }
 }
@@ -119,7 +118,12 @@ pub(super) fn adjust_arg_for_abi<'tcx>(
             let (a, b) = arg.load_scalar_pair(fx);
             Pair(a, b)
         }
-        PassMode::ByRef => Single(arg.force_stack(fx).get_addr(fx)),
+        PassMode::ByRef { sized: _ } => {
+            match arg.force_stack(fx) {
+                (ptr, None) => Single(ptr.get_addr(fx)),
+                (ptr, Some(meta)) => Pair(ptr.get_addr(fx), meta),
+            }
+        }
     }
 }
 
@@ -158,6 +162,10 @@ pub(super) fn cvalue_for_param<'tcx>(
             let (a, b) = ebb_params.assert_pair();
             Some(CValue::by_val_pair(a, b, layout))
         }
-        PassMode::ByRef => Some(CValue::by_ref(Pointer::new(ebb_params.assert_single()), layout)),
+        PassMode::ByRef { sized: true } => Some(CValue::by_ref(Pointer::new(ebb_params.assert_single()), layout)),
+        PassMode::ByRef { sized: false } => {
+            let (ptr, meta) = ebb_params.assert_pair();
+            Some(CValue::by_ref_unsized(Pointer::new(ptr), meta, layout))
+        }
     }
 }
diff --git a/src/abi/returning.rs b/src/abi/returning.rs
@@ -9,7 +9,7 @@ pub fn can_return_to_ssa_var<'tcx>(tcx: TyCtxt<'tcx>, dest_layout: TyLayout<'tcx
     match get_pass_mode(tcx, dest_layout) {
         PassMode::NoPass | PassMode::ByVal(_) => true,
         // FIXME Make it possible to return ByValPair and ByRef to an ssa var.
-        PassMode::ByValPair(_, _) | PassMode::ByRef => false
+        PassMode::ByValPair(_, _) | PassMode::ByRef { sized: _ } => false
     }
 }
 
@@ -33,13 +33,14 @@ pub(super) fn codegen_return_param(
 
             Empty
         }
-        PassMode::ByRef => {
+        PassMode::ByRef { sized: true } => {
             let ret_param = fx.bcx.append_ebb_param(start_ebb, fx.pointer_type);
             fx.local_map
                 .insert(RETURN_PLACE, CPlace::for_ptr(Pointer::new(ret_param), ret_layout));
 
             Single(ret_param)
         }
+        PassMode::ByRef { sized: false } => todo!(),
     };
 
     #[cfg(debug_assertions)]
@@ -65,10 +66,11 @@ pub(super) fn codegen_with_call_return_arg<'tcx, B: Backend, T>(
     let output_pass_mode = get_pass_mode(fx.tcx, ret_layout);
     let return_ptr = match output_pass_mode {
         PassMode::NoPass => None,
-        PassMode::ByRef => match ret_place {
+        PassMode::ByRef { sized: true } => match ret_place {
             Some(ret_place) => Some(ret_place.to_ptr(fx).get_addr(fx)),
             None => Some(fx.bcx.ins().iconst(fx.pointer_type, 43)),
         },
+        PassMode::ByRef { sized: false } => todo!(),
         PassMode::ByVal(_) | PassMode::ByValPair(_, _) => None,
     };
 
@@ -89,17 +91,19 @@ pub(super) fn codegen_with_call_return_arg<'tcx, B: Backend, T>(
                 ret_place.write_cvalue(fx, CValue::by_val_pair(ret_val_a, ret_val_b, ret_layout));
             }
         }
-        PassMode::ByRef => {}
+        PassMode::ByRef { sized: true } => {}
+        PassMode::ByRef { sized: false } => todo!(),
     }
 
     (call_inst, meta)
 }
 
 pub fn codegen_return(fx: &mut FunctionCx<impl Backend>) {
     match get_pass_mode(fx.tcx, return_layout(fx)) {
-        PassMode::NoPass | PassMode::ByRef => {
+        PassMode::NoPass | PassMode::ByRef { sized: true } => {
             fx.bcx.ins().return_(&[]);
         }
+        PassMode::ByRef { sized: false } => todo!(),
         PassMode::ByVal(_) => {
             let place = fx.get_local_place(RETURN_PLACE);
             let ret_val = place.to_cvalue(fx).load_scalar(fx);
diff --git a/src/value_and_place.rs b/src/value_and_place.rs
@@ -66,14 +66,18 @@ pub struct CValue<'tcx>(CValueInner, TyLayout<'tcx>);
 
 #[derive(Debug, Copy, Clone)]
 enum CValueInner {
-    ByRef(Pointer),
+    ByRef(Pointer, Option<Value>),
     ByVal(Value),
     ByValPair(Value, Value),
 }
 
 impl<'tcx> CValue<'tcx> {
     pub fn by_ref(ptr: Pointer, layout: TyLayout<'tcx>) -> CValue<'tcx> {
-        CValue(CValueInner::ByRef(ptr), layout)
+        CValue(CValueInner::ByRef(ptr, None), layout)
+    }
+
+    pub fn by_ref_unsized(ptr: Pointer, meta: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {
+        CValue(CValueInner::ByRef(ptr, Some(meta)), layout)
     }
 
     pub fn by_val(value: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {
@@ -89,24 +93,24 @@ impl<'tcx> CValue<'tcx> {
     }
 
     // FIXME remove
-    pub fn force_stack<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> Pointer {
+    pub fn force_stack<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> (Pointer, Option<Value>) {
         let layout = self.1;
         match self.0 {
-            CValueInner::ByRef(ptr) => ptr,
+            CValueInner::ByRef(ptr, meta) => (ptr, meta),
             CValueInner::ByVal(_) | CValueInner::ByValPair(_, _) => {
                 let cplace = CPlace::new_stack_slot(fx, layout);
                 cplace.write_cvalue(fx, self);
-                cplace.to_ptr(fx)
+                (cplace.to_ptr(fx), None)
             }
         }
     }
 
-    pub fn try_to_addr(self) -> Option<Value> {
+    pub fn try_to_addr(self) -> Option<(Value, Option<Value>)> {
         match self.0 {
-            CValueInner::ByRef(ptr) => {
+            CValueInner::ByRef(ptr, meta) => {
                 if let Some((base_addr, offset)) = ptr.try_get_addr_and_offset() {
                     if offset == Offset32::new(0) {
-                        Some(base_addr)
+                        Some((base_addr, meta))
                     } else {
                         None
                     }
@@ -122,7 +126,7 @@ impl<'tcx> CValue<'tcx> {
     pub fn load_scalar<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> Value {
         let layout = self.1;
         match self.0 {
-            CValueInner::ByRef(ptr) => {
+            CValueInner::ByRef(ptr, None) => {
                 let clif_ty = match layout.abi {
                     layout::Abi::Scalar(ref scalar) => scalar_to_clif_type(fx.tcx, scalar.clone()),
                     layout::Abi::Vector { ref element, count } => {
@@ -134,6 +138,7 @@ impl<'tcx> CValue<'tcx> {
                 ptr.load(fx, clif_ty, MemFlags::new())
             }
             CValueInner::ByVal(value) => value,
+            CValueInner::ByRef(_, Some(_)) => bug!("load_scalar for unsized value not allowed"),
             CValueInner::ByValPair(_, _) => bug!("Please use load_scalar_pair for ByValPair"),
         }
     }
@@ -145,7 +150,7 @@ impl<'tcx> CValue<'tcx> {
     ) -> (Value, Value) {
         let layout = self.1;
         match self.0 {
-            CValueInner::ByRef(ptr) => {
+            CValueInner::ByRef(ptr, None) => {
                 let (a_scalar, b_scalar) = match &layout.abi {
                     layout::Abi::ScalarPair(a, b) => (a, b),
                     _ => unreachable!("load_scalar_pair({:?})", self),
@@ -157,6 +162,7 @@ impl<'tcx> CValue<'tcx> {
                 let val2 = ptr.offset(fx, b_offset).load(fx, clif_ty2, MemFlags::new());
                 (val1, val2)
             }
+            CValueInner::ByRef(_, Some(_)) => bug!("load_scalar_pair for unsized value not allowed"),
             CValueInner::ByVal(_) => bug!("Please use load_scalar for ByVal"),
             CValueInner::ByValPair(val1, val2) => (val1, val2),
         }
@@ -182,10 +188,11 @@ impl<'tcx> CValue<'tcx> {
                     _ => unreachable!("value_field for ByVal with abi {:?}", layout.abi),
                 }
             }
-            CValueInner::ByRef(ptr) => {
+            CValueInner::ByRef(ptr, None) => {
                 let (field_ptr, field_layout) = codegen_field(fx, ptr, None, layout, field);
                 CValue::by_ref(field_ptr, field_layout)
             }
+            CValueInner::ByRef(_, Some(_)) => todo!(),
             _ => bug!("place_field for {:?}", self),
         }
     }
@@ -495,7 +502,7 @@ impl<'tcx> CPlace<'tcx> {
                     dst_layout.abi
                 );
             }
-            CValueInner::ByRef(from_ptr) => {
+            CValueInner::ByRef(from_ptr, None) => {
                 let from_addr = from_ptr.get_addr(fx);
                 let to_addr = to_ptr.get_addr(fx);
                 let src_layout = from.1;
@@ -511,6 +518,7 @@ impl<'tcx> CPlace<'tcx> {
                     src_align,
                 );
             }
+            CValueInner::ByRef(_, Some(_)) => todo!(),
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ pub enum PassMode {`
`7`	`7`	`NoPass,`
`8`	`8`	`ByVal(Type),`
`9`	`9`	`ByValPair(Type, Type),`
`10`		`- ByRef,`
	`10`	`+ ByRef { sized: bool },`
`11`	`11`	`}`
`12`	`12`
`13`	`13`	`#[derive(Copy, Clone, Debug)]`
`@@ -70,14 +70,13 @@ impl PassMode {`
`70`	`70`	`PassMode::NoPass => Empty,`
`71`	`71`	`PassMode::ByVal(clif_type) => Single(clif_type),`
`72`	`72`	`PassMode::ByValPair(a, b) => Pair(a, b),`
`73`		`- PassMode::ByRef => Single(pointer_ty(tcx)),`
	`73`	`+ PassMode::ByRef { sized: true } => Single(pointer_ty(tcx)),`
	`74`	`+ PassMode::ByRef { sized: false } => Pair(pointer_ty(tcx), pointer_ty(tcx)),`
`74`	`75`	`}`
`75`	`76`	`}`
`76`	`77`	`}`
`77`	`78`
`78`	`79`	`pub fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyLayout<'tcx>) -> PassMode {`
`79`		`- assert!(!layout.is_unsized());`
`80`		`-`
`81`	`80`	`if layout.is_zst() {`
`82`	`81`	`// WARNING zst arguments must never be passed, as that will break CastKind::ClosureFnPointer`
`83`	`82`	`PassMode::NoPass`
`@@ -94,16 +93,16 @@ pub fn get_pass_mode<'tcx>(tcx: TyCtxt<'tcx>, layout: TyLayout<'tcx>) -> PassMod`
`94`	`93`	`// Returning (i128, i128) by-val-pair would take 4 regs, while only 3 are`
`95`	`94`	`// available on x86_64. Cranelift gets confused when too many return params`
`96`	`95`	`// are used.`
`97`		`- PassMode::ByRef`
	`96`	`+ PassMode::ByRef { sized: true }`
`98`	`97`	`} else {`
`99`	`98`	`PassMode::ByValPair(a, b)`
`100`	`99`	`}`
`101`	`100`	`}`
`102`	`101`
`103`	`102`	`// FIXME implement Vector Abi in a cg_llvm compatible way`
`104`		`- layout::Abi::Vector { .. } => PassMode::ByRef,`
	`103`	`+ layout::Abi::Vector { .. } => PassMode::ByRef { sized: true },`
`105`	`104`
`106`		`- layout::Abi::Aggregate { .. } => PassMode::ByRef,`
	`105`	`+ &layout::Abi::Aggregate { sized } => PassMode::ByRef { sized },`
`107`	`106`	`}`
`108`	`107`	`}`
`109`	`108`	`}`
`@@ -119,7 +118,12 @@ pub(super) fn adjust_arg_for_abi<'tcx>(`
`119`	`118`	`let (a, b) = arg.load_scalar_pair(fx);`
`120`	`119`	`Pair(a, b)`
`121`	`120`	`}`
`122`		`- PassMode::ByRef => Single(arg.force_stack(fx).get_addr(fx)),`
	`121`	`+ PassMode::ByRef { sized: _ } => {`
	`122`	`+ match arg.force_stack(fx) {`
	`123`	`+ (ptr, None) => Single(ptr.get_addr(fx)),`
	`124`	`+ (ptr, Some(meta)) => Pair(ptr.get_addr(fx), meta),`
	`125`	`+ }`
	`126`	`+ }`
`123`	`127`	`}`
`124`	`128`	`}`
`125`	`129`
`@@ -158,6 +162,10 @@ pub(super) fn cvalue_for_param<'tcx>(`
`158`	`162`	`let (a, b) = ebb_params.assert_pair();`
`159`	`163`	`Some(CValue::by_val_pair(a, b, layout))`
`160`	`164`	`}`
`161`		`- PassMode::ByRef => Some(CValue::by_ref(Pointer::new(ebb_params.assert_single()), layout)),`
	`165`	`+ PassMode::ByRef { sized: true } => Some(CValue::by_ref(Pointer::new(ebb_params.assert_single()), layout)),`
	`166`	`+ PassMode::ByRef { sized: false } => {`
	`167`	`+ let (ptr, meta) = ebb_params.assert_pair();`
	`168`	`+ Some(CValue::by_ref_unsized(Pointer::new(ptr), meta, layout))`
	`169`	`+ }`
`162`	`170`	`}`
`163`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -66,14 +66,18 @@ pub struct CValue<'tcx>(CValueInner, TyLayout<'tcx>);`
`66`	`66`
`67`	`67`	`#[derive(Debug, Copy, Clone)]`
`68`	`68`	`enum CValueInner {`
`69`		`- ByRef(Pointer),`
	`69`	`+ ByRef(Pointer, Option<Value>),`
`70`	`70`	`ByVal(Value),`
`71`	`71`	`ByValPair(Value, Value),`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`impl<'tcx> CValue<'tcx> {`
`75`	`75`	`pub fn by_ref(ptr: Pointer, layout: TyLayout<'tcx>) -> CValue<'tcx> {`
`76`		`- CValue(CValueInner::ByRef(ptr), layout)`
	`76`	`+ CValue(CValueInner::ByRef(ptr, None), layout)`
	`77`	`+ }`
	`78`	`+`
	`79`	`+ pub fn by_ref_unsized(ptr: Pointer, meta: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {`
	`80`	`+ CValue(CValueInner::ByRef(ptr, Some(meta)), layout)`
`77`	`81`	`}`
`78`	`82`
`79`	`83`	`pub fn by_val(value: Value, layout: TyLayout<'tcx>) -> CValue<'tcx> {`
`@@ -89,24 +93,24 @@ impl<'tcx> CValue<'tcx> {`
`89`	`93`	`}`
`90`	`94`
`91`	`95`	`// FIXME remove`
`92`		`- pub fn force_stack<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> Pointer {`
	`96`	`+ pub fn force_stack<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> (Pointer, Option<Value>) {`
`93`	`97`	`let layout = self.1;`
`94`	`98`	`match self.0 {`
`95`		`- CValueInner::ByRef(ptr) => ptr,`
	`99`	`+ CValueInner::ByRef(ptr, meta) => (ptr, meta),`
`96`	`100`	`CValueInner::ByVal(_) \| CValueInner::ByValPair(_, _) => {`
`97`	`101`	`let cplace = CPlace::new_stack_slot(fx, layout);`
`98`	`102`	`cplace.write_cvalue(fx, self);`
`99`		`- cplace.to_ptr(fx)`
	`103`	`+ (cplace.to_ptr(fx), None)`
`100`	`104`	`}`
`101`	`105`	`}`
`102`	`106`	`}`
`103`	`107`
`104`		`- pub fn try_to_addr(self) -> Option<Value> {`
	`108`	`+ pub fn try_to_addr(self) -> Option<(Value, Option<Value>)> {`
`105`	`109`	`match self.0 {`
`106`		`- CValueInner::ByRef(ptr) => {`
	`110`	`+ CValueInner::ByRef(ptr, meta) => {`
`107`	`111`	`if let Some((base_addr, offset)) = ptr.try_get_addr_and_offset() {`
`108`	`112`	`if offset == Offset32::new(0) {`
`109`		`- Some(base_addr)`
	`113`	`+ Some((base_addr, meta))`
`110`	`114`	`} else {`
`111`	`115`	`None`
`112`	`116`	`}`
`@@ -122,7 +126,7 @@ impl<'tcx> CValue<'tcx> {`
`122`	`126`	`pub fn load_scalar<'a>(self, fx: &mut FunctionCx<'_, 'tcx, impl Backend>) -> Value {`
`123`	`127`	`let layout = self.1;`
`124`	`128`	`match self.0 {`
`125`		`- CValueInner::ByRef(ptr) => {`
	`129`	`+ CValueInner::ByRef(ptr, None) => {`
`126`	`130`	`let clif_ty = match layout.abi {`
`127`	`131`	`layout::Abi::Scalar(ref scalar) => scalar_to_clif_type(fx.tcx, scalar.clone()),`
`128`	`132`	`layout::Abi::Vector { ref element, count } => {`
`@@ -134,6 +138,7 @@ impl<'tcx> CValue<'tcx> {`
`134`	`138`	`ptr.load(fx, clif_ty, MemFlags::new())`
`135`	`139`	`}`
`136`	`140`	`CValueInner::ByVal(value) => value,`
	`141`	`+ CValueInner::ByRef(_, Some(_)) => bug!("load_scalar for unsized value not allowed"),`
`137`	`142`	`CValueInner::ByValPair(_, _) => bug!("Please use load_scalar_pair for ByValPair"),`
`138`	`143`	`}`
`139`	`144`	`}`
`@@ -145,7 +150,7 @@ impl<'tcx> CValue<'tcx> {`
`145`	`150`	`) -> (Value, Value) {`
`146`	`151`	`let layout = self.1;`
`147`	`152`	`match self.0 {`
`148`		`- CValueInner::ByRef(ptr) => {`
	`153`	`+ CValueInner::ByRef(ptr, None) => {`
`149`	`154`	`let (a_scalar, b_scalar) = match &layout.abi {`
`150`	`155`	`layout::Abi::ScalarPair(a, b) => (a, b),`
`151`	`156`	`_ => unreachable!("load_scalar_pair({:?})", self),`
`@@ -157,6 +162,7 @@ impl<'tcx> CValue<'tcx> {`
`157`	`162`	`let val2 = ptr.offset(fx, b_offset).load(fx, clif_ty2, MemFlags::new());`
`158`	`163`	`(val1, val2)`
`159`	`164`	`}`
	`165`	`+ CValueInner::ByRef(_, Some(_)) => bug!("load_scalar_pair for unsized value not allowed"),`
`160`	`166`	`CValueInner::ByVal(_) => bug!("Please use load_scalar for ByVal"),`
`161`	`167`	`CValueInner::ByValPair(val1, val2) => (val1, val2),`
`162`	`168`	`}`
`@@ -182,10 +188,11 @@ impl<'tcx> CValue<'tcx> {`
`182`	`188`	`_ => unreachable!("value_field for ByVal with abi {:?}", layout.abi),`
`183`	`189`	`}`
`184`	`190`	`}`
`185`		`- CValueInner::ByRef(ptr) => {`
	`191`	`+ CValueInner::ByRef(ptr, None) => {`
`186`	`192`	`let (field_ptr, field_layout) = codegen_field(fx, ptr, None, layout, field);`
`187`	`193`	`CValue::by_ref(field_ptr, field_layout)`
`188`	`194`	`}`
	`195`	`+ CValueInner::ByRef(_, Some(_)) => todo!(),`
`189`	`196`	`_ => bug!("place_field for {:?}", self),`
`190`	`197`	`}`
`191`	`198`	`}`
`@@ -495,7 +502,7 @@ impl<'tcx> CPlace<'tcx> {`
`495`	`502`	`dst_layout.abi`
`496`	`503`	`);`
`497`	`504`	`}`
`498`		`- CValueInner::ByRef(from_ptr) => {`
	`505`	`+ CValueInner::ByRef(from_ptr, None) => {`
`499`	`506`	`let from_addr = from_ptr.get_addr(fx);`
`500`	`507`	`let to_addr = to_ptr.get_addr(fx);`
`501`	`508`	`let src_layout = from.1;`
`@@ -511,6 +518,7 @@ impl<'tcx> CPlace<'tcx> {`
`511`	`518`	`src_align,`
`512`	`519`	`);`
`513`	`520`	`}`
	`521`	`+ CValueInner::ByRef(_, Some(_)) => todo!(),`
`514`	`522`	`}`
`515`	`523`	`}`
`516`	`524`