Couple of minor refactors

Author: bjorn3

src/abi/mod.rs

@@ -31,9 +31,9 @@ use crate::base::codegen_unwind_terminate;
 use crate::debuginfo::EXCEPTION_HANDLER_CLEANUP;
 use crate::prelude::*;
 
-pub(super) struct ArgValue<'tcx> {
-    pub(super) value: Option<CValue<'tcx>>,
-    pub(super) is_underaligned_pointee: bool,
+struct ArgValue<'tcx> {
+    value: CValue<'tcx>,
+    is_underaligned_pointee: bool,
 }
 
 fn clif_sig_from_fn_abi<'tcx>(
@@ -248,9 +248,10 @@ pub(crate) fn codegen_fn_prelude<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, start_
         self::returning::codegen_return_param(fx, &ssa_analyzed, &mut block_params_iter);
     assert_eq!(fx.local_map.push(ret_place), RETURN_PLACE);
 
+    // None means pass_mode == NoPass
     enum ArgKind<'tcx> {
-        Normal(ArgValue<'tcx>),
-        Spread(Vec<ArgValue<'tcx>>),
+        Normal(Option<ArgValue<'tcx>>),
+        Spread(Vec<Option<ArgValue<'tcx>>>),
     }
 
     // FIXME implement variadics in cranelift
@@ -284,20 +285,17 @@ pub(crate) fn codegen_fn_prelude<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, start_
                 let mut params = Vec::new();
                 for (i, _arg_ty) in tupled_arg_tys.iter().enumerate() {
                     let arg_abi = arg_abis_iter.next().unwrap();
-                    params.push(cvalue_for_param(
-                        fx,
-                        Some(local),
-                        Some(i),
-                        arg_abi,
-                        &mut block_params_iter,
-                    ));
+                    let param =
+                        cvalue_for_param(fx, Some(local), Some(i), arg_abi, &mut block_params_iter);
+                    params.push(param);
                 }
 
                 (local, ArgKind::Spread(params), arg_ty)
             } else {
                 let arg_abi = arg_abis_iter.next().unwrap();
-                let arg = cvalue_for_param(fx, Some(local), None, arg_abi, &mut block_params_iter);
-                (local, ArgKind::Normal(arg), arg_ty)
+                let param =
+                    cvalue_for_param(fx, Some(local), None, arg_abi, &mut block_params_iter);
+                (local, ArgKind::Normal(param), arg_ty)
             }
         })
         .collect::<Vec<(Local, ArgKind<'tcx>, Ty<'tcx>)>>();
@@ -306,12 +304,12 @@ pub(crate) fn codegen_fn_prelude<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, start_
     if fx.instance.def.requires_caller_location(fx.tcx) {
         // Store caller location for `#[track_caller]`.
         let arg_abi = arg_abis_iter.next().unwrap();
-        let arg = cvalue_for_param(fx, None, None, arg_abi, &mut block_params_iter);
+        let param = cvalue_for_param(fx, None, None, arg_abi, &mut block_params_iter).unwrap();
         assert!(
-            !arg.is_underaligned_pointee,
+            !param.is_underaligned_pointee,
             "caller location argument should not be underaligned",
         );
-        fx.caller_location = Some(arg.value.unwrap());
+        fx.caller_location = Some(param.value);
     }
 
     assert_eq!(arg_abis_iter.next(), None, "ArgAbi left behind for {:?}", fx.fn_abi);
@@ -322,7 +320,7 @@ pub(crate) fn codegen_fn_prelude<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, start_
     for (local, arg_kind, ty) in func_params {
         // 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.
-        if let ArgKind::Normal(ArgValue { value: Some(val), is_underaligned_pointee: false }) =
+        if let ArgKind::Normal(Some(ArgValue { value: val, is_underaligned_pointee: false })) =
             arg_kind
         {
             if let Some((addr, meta)) = val.try_to_ptr() {
@@ -349,24 +347,23 @@ pub(crate) fn codegen_fn_prelude<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, start_
         assert_eq!(fx.local_map.push(place), local);
 
         match arg_kind {
-            ArgKind::Normal(ArgValue { value: Some(param), is_underaligned_pointee }) => {
-                if is_underaligned_pointee {
-                    place.write_cvalue_transmute(fx, param);
-                } else {
-                    place.write_cvalue(fx, param);
+            ArgKind::Normal(param) => {
+                if let Some(param) = param {
+                    if param.is_underaligned_pointee {
+                        place.write_cvalue_transmute(fx, param.value);
+                    } else {
+                        place.write_cvalue(fx, param.value);
+                    }
                 }
             }
-            ArgKind::Normal(ArgValue { value: None, is_underaligned_pointee: _ }) => {}
             ArgKind::Spread(params) => {
-                for (i, ArgValue { value: param, is_underaligned_pointee }) in
-                    params.into_iter().enumerate()
-                {
+                for (i, param) in params.into_iter().enumerate() {
                     if let Some(param) = param {
                         let field_place = place.place_field(fx, FieldIdx::new(i));
-                        if is_underaligned_pointee {
-                            field_place.write_cvalue_transmute(fx, param);
+                        if param.is_underaligned_pointee {
+                            field_place.write_cvalue_transmute(fx, param.value);
                         } else {
-                            field_place.write_cvalue(fx, param);
+                            field_place.write_cvalue(fx, param.value);
                         }
                     }
                 }

src/abi/pass_mode.rs

@@ -285,7 +285,7 @@ pub(super) fn cvalue_for_param<'tcx>(
     local_field: Option<usize>,
     arg_abi: &ArgAbi<'tcx, Ty<'tcx>>,
     block_params_iter: &mut impl Iterator<Item = Value>,
-) -> ArgValue<'tcx> {
+) -> Option<ArgValue<'tcx>> {
     let block_params = arg_abi
         .get_abi_param(fx.tcx)
         .into_iter()
@@ -306,19 +306,18 @@ pub(super) fn cvalue_for_param<'tcx>(
         arg_abi.layout,
     );
 
-    let mut is_underaligned_pointee = false;
     let value = match arg_abi.mode {
-        PassMode::Ignore => None,
+        PassMode::Ignore => return None,
         PassMode::Direct(_) => {
             assert_eq!(block_params.len(), 1, "{:?}", block_params);
-            Some(CValue::by_val(block_params[0], arg_abi.layout))
+            CValue::by_val(block_params[0], arg_abi.layout)
         }
         PassMode::Pair(_, _) => {
             assert_eq!(block_params.len(), 2, "{:?}", block_params);
-            Some(CValue::by_val_pair(block_params[0], block_params[1], arg_abi.layout))
+            CValue::by_val_pair(block_params[0], block_params[1], arg_abi.layout)
         }
         PassMode::Cast { ref cast, .. } => {
-            Some(from_casted_value(fx, &block_params, arg_abi.layout, cast))
+            from_casted_value(fx, &block_params, arg_abi.layout, cast)
         }
         PassMode::Indirect { attrs, meta_attrs: None, on_stack: _ } => {
             assert_eq!(block_params.len(), 1, "{:?}", block_params);
@@ -327,24 +326,22 @@ pub(super) fn cvalue_for_param<'tcx>(
                 && arg_abi.layout.is_sized()
                 && arg_abi.layout.size != Size::ZERO
             {
-                is_underaligned_pointee = true;
                 // Underaligned pointer: treat as `[u8; size]` and transmute-copy into the real type.
                 let bytes_ty = Ty::new_array(fx.tcx, fx.tcx.types.u8, arg_abi.layout.size.bytes());
                 let bytes_layout = fx.layout_of(bytes_ty);
-                Some(CValue::by_ref(Pointer::new(block_params[0]), bytes_layout))
+                return Some(ArgValue {
+                    value: CValue::by_ref(Pointer::new(block_params[0]), bytes_layout),
+                    is_underaligned_pointee: true,
+                });
             } else {
-                Some(CValue::by_ref(Pointer::new(block_params[0]), arg_abi.layout))
+                CValue::by_ref(Pointer::new(block_params[0]), arg_abi.layout)
             }
         }
         PassMode::Indirect { attrs: _, meta_attrs: Some(_), on_stack: _ } => {
             assert_eq!(block_params.len(), 2, "{:?}", block_params);
-            Some(CValue::by_ref_unsized(
-                Pointer::new(block_params[0]),
-                block_params[1],
-                arg_abi.layout,
-            ))
+            CValue::by_ref_unsized(Pointer::new(block_params[0]), block_params[1], arg_abi.layout)
         }
     };
 
-    ArgValue { value, is_underaligned_pointee }
+    Some(ArgValue { value, is_underaligned_pointee: false })
 }