We only use Immediate::Uninit for zsts and uninit locals

Author: oli-obk

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -240,7 +240,7 @@ pub(super) fn op_to_const<'tcx>(
                 let meta = b.to_target_usize(ecx).expect(msg);
                 ConstValue::Slice { data, meta }
             }
-            Immediate::Uninit => bug!("`Uninit` is not a valid value for {}", op.layout.ty),
+            Immediate::Uninit => bug!("`Zst` is not a valid value for {}", op.layout.ty),
         },
     }
 }

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -152,7 +152,11 @@ impl<Prov: Provenance> Immediate<Prov> {
                 }
             }
             (Immediate::Uninit, _) => {
-                assert!(abi.is_sized(), "{msg}: unsized immediates are not a thing");
+                assert_matches!(
+                    abi,
+                    BackendRepr::Memory { sized: true },
+                    "{msg}: unsized zsts are not a thing"
+                );
             }
             _ => {
                 bug!("{msg}: value {self:?} does not match ABI {abi:?})",)
@@ -267,7 +271,7 @@ impl<'tcx, Prov: Provenance> ImmTy<'tcx, Prov> {
             match (imm, layout.backend_repr) {
                 (Immediate::Scalar(..), BackendRepr::Scalar(..)) => true,
                 (Immediate::ScalarPair(..), BackendRepr::ScalarPair(..)) => true,
-                (Immediate::Uninit, _) if layout.is_sized() => true,
+                (Immediate::Uninit, _) if layout.is_sized() && layout.is_zst() => true,
                 _ => false,
             },
             "immediate {imm:?} does not fit to layout {layout:?}",
@@ -276,8 +280,9 @@ impl<'tcx, Prov: Provenance> ImmTy<'tcx, Prov> {
     }
 
     #[inline]
-    pub fn uninit(layout: TyAndLayout<'tcx>) -> Self {
+    pub fn zst(layout: TyAndLayout<'tcx>) -> Self {
         debug_assert!(layout.is_sized(), "immediates must be sized");
+        debug_assert!(layout.is_zst());
         ImmTy { imm: Immediate::Uninit, layout }
     }
 
@@ -382,15 +387,16 @@ impl<'tcx, Prov: Provenance> ImmTy<'tcx, Prov> {
         // This makes several assumptions about what layouts we will encounter; we match what
         // codegen does as good as we can (see `extract_field` in `rustc_codegen_ssa/src/mir/operand.rs`).
         let inner_val: Immediate<_> = match (**self, self.layout.backend_repr) {
-            // If the entire value is uninit, then so is the field (can happen in ConstProp).
-            (Immediate::Uninit, _) => Immediate::Uninit,
             // If the field is uninhabited, we can forget the data (can happen in ConstProp).
             // `enum S { A(!), B, C }` is an example of an enum with Scalar layout that
             // has an uninhabited variant, which means this case is possible.
             _ if layout.is_uninhabited() => Immediate::Uninit,
             // the field contains no information, can be left uninit
             // (Scalar/ScalarPair can contain even aligned ZST, not just 1-ZST)
             _ if layout.is_zst() => Immediate::Uninit,
+            // If the value is a zst, then so is the field (can happen in ConstProp).
+            // This is handled by the zst field read above.
+            (Immediate::Uninit, _) => unreachable!(),
             // some fieldless enum variants can have non-zero size but still `Aggregate` ABI... try
             // to detect those here and also give them no data
             _ if matches!(layout.backend_repr, BackendRepr::Memory { .. })
@@ -572,8 +578,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         }
 
         let Some(alloc) = self.get_place_alloc(mplace)? else {
-            // zero-sized type can be left uninit
-            return interp_ok(Some(ImmTy::uninit(mplace.layout)));
+            return interp_ok(Some(ImmTy::zst(mplace.layout)));
         };
 
         // It may seem like all types with `Scalar` or `ScalarPair` ABI are fair game at this point.

compiler/rustc_const_eval/src/interpret/operator.rs

@@ -496,7 +496,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                     }
                     MemPlaceMeta::None => {
                         let unit_layout = self.layout_of(self.tcx.types.unit)?;
-                        ImmTy::uninit(unit_layout)
+                        ImmTy::zst(unit_layout)
                     }
                 })
             }

compiler/rustc_const_eval/src/interpret/place.rs

@@ -722,7 +722,7 @@ where
                 // We don't have to reset padding here, `write_immediate` will anyway do a validation run.
                 interp_ok(())
             }
-            Immediate::Uninit => alloc.write_uninit_full(),
+            Immediate::Uninit => unreachable!("zst have been skipped in the alloc load above"),
         }
     }
 

compiler/rustc_mir_transform/src/gvn.rs

@@ -407,7 +407,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
                 let variant = if ty.is_enum() { Some(variant) } else { None };
                 let ty = self.ecx.layout_of(ty).ok()?;
                 if ty.is_zst() {
-                    ImmTy::uninit(ty).into()
+                    ImmTy::zst(ty).into()
                 } else if matches!(kind, AggregateTy::RawPtr { .. }) {
                     // Pointers don't have fields, so don't `project_field` them.
                     let data = self.ecx.read_pointer(fields[0]).discard_err()?;

src/tools/miri/src/shims/native_lib/mod.rs

@@ -93,7 +93,7 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // have the output_type `Tuple([])`.
                 ty::Tuple(t_list) if (*t_list).deref().is_empty() => {
                     unsafe { ffi::call::<()>(ptr, libffi_args.as_slice()) };
-                    break 'res interp_ok(ImmTy::uninit(dest.layout));
+                    break 'res interp_ok(ImmTy::zst(dest.layout));
                 }
                 ty::RawPtr(..) => {
                     let x = unsafe { ffi::call::<*const ()>(ptr, libffi_args.as_slice()) };