Remove ConstValue::Slice

Author: oli-obk

Cargo.lock

@@ -3821,6 +3821,7 @@ dependencies = [
  "rustc_apfloat",
  "rustc_arena",
  "rustc_ast",
+ "rustc_const_eval",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_fluent_macro",

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -227,16 +227,6 @@ pub(crate) fn codegen_const_value<'tcx>(
                 .offset_i64(fx, i64::try_from(offset.bytes()).unwrap()),
             layout,
         ),
-        ConstValue::Slice { data, start, end } => {
-            let ptr = pointer_for_allocation(fx, data)
-                .offset_i64(fx, i64::try_from(start).unwrap())
-                .get_addr(fx);
-            let len = fx
-                .bcx
-                .ins()
-                .iconst(fx.pointer_type, i64::try_from(end.checked_sub(start).unwrap()).unwrap());
-            CValue::by_val_pair(ptr, len, layout)
-        }
     }
 }
 

compiler/rustc_codegen_ssa/src/mir/operand.rs

@@ -8,7 +8,7 @@ use crate::traits::*;
 use crate::MemFlags;
 
 use rustc_middle::mir;
-use rustc_middle::mir::interpret::{alloc_range, ConstValue, Pointer, Scalar};
+use rustc_middle::mir::interpret::{alloc_range, ConstValue};
 use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_middle::ty::Ty;
 use rustc_target::abi::{self, Abi, Align, Size};
@@ -100,22 +100,6 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
                 OperandValue::Immediate(llval)
             }
             ConstValue::ZeroSized => return OperandRef::zero_sized(layout),
-            ConstValue::Slice { data, start, end } => {
-                let Abi::ScalarPair(a_scalar, _) = layout.abi else {
-                    bug!("from_const: invalid ScalarPair layout: {:#?}", layout);
-                };
-                let a = Scalar::from_pointer(
-                    Pointer::new(bx.tcx().create_memory_alloc(data), Size::from_bytes(start)),
-                    &bx.tcx(),
-                );
-                let a_llval = bx.scalar_to_backend(
-                    a,
-                    a_scalar,
-                    bx.scalar_pair_element_backend_type(layout, 0, true),
-                );
-                let b_llval = bx.const_usize((end - start) as u64);
-                OperandValue::Pair(a_llval, b_llval)
-            }
             ConstValue::ByRef { alloc, offset } => {
                 return Self::from_const_alloc(bx, layout, alloc, offset);
             }

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -18,9 +18,9 @@ use super::{CompileTimeEvalContext, CompileTimeInterpreter};
 use crate::errors;
 use crate::interpret::eval_nullary_intrinsic;
 use crate::interpret::{
-    intern_const_alloc_recursive, Allocation, ConstAlloc, ConstValue, CtfeValidationMode, GlobalId,
-    Immediate, InternKind, InterpCx, InterpError, InterpResult, MPlaceTy, MemoryKind, OpTy,
-    RefTracking, StackPopCleanup,
+    intern_const_alloc_recursive, ConstAlloc, ConstValue, CtfeValidationMode, GlobalId, Immediate,
+    InternKind, InterpCx, InterpError, InterpResult, MPlaceTy, MemoryKind, OpTy, RefTracking,
+    StackPopCleanup,
 };
 
 // Returns a pointer to where the result lives
@@ -108,7 +108,7 @@ pub(super) fn mk_eval_cx<'mir, 'tcx>(
 /// type system.
 #[instrument(skip(ecx), level = "debug")]
 pub(super) fn op_to_const<'tcx>(
-    ecx: &CompileTimeEvalContext<'_, 'tcx>,
+    ecx: &mut CompileTimeEvalContext<'_, 'tcx>,
     op: &OpTy<'tcx>,
 ) -> ConstValue<'tcx> {
     // We do not have value optimizations for everything.
@@ -143,12 +143,14 @@ pub(super) fn op_to_const<'tcx>(
 
     debug!(?immediate);
 
+    let tcx = ecx.tcx;
+
     // We know `offset` is relative to the allocation, so we can use `into_parts`.
     let to_const_value = |mplace: &MPlaceTy<'_>| {
         debug!("to_const_value(mplace: {:?})", mplace);
         match mplace.ptr.into_parts() {
             (Some(alloc_id), offset) => {
-                let alloc = ecx.tcx.global_alloc(alloc_id).unwrap_memory();
+                let alloc = tcx.global_alloc(alloc_id).unwrap_memory();
                 ConstValue::ByRef { alloc, offset }
             }
             (None, offset) => {
@@ -169,24 +171,12 @@ pub(super) fn op_to_const<'tcx>(
         Right(imm) => match *imm {
             _ if imm.layout.is_zst() => ConstValue::ZeroSized,
             Immediate::Scalar(x) => ConstValue::Scalar(x),
-            Immediate::ScalarPair(a, b) => {
-                debug!("ScalarPair(a: {:?}, b: {:?})", a, b);
-                // We know `offset` is relative to the allocation, so we can use `into_parts`.
-                let (data, start) = match a.to_pointer(ecx).unwrap().into_parts() {
-                    (Some(alloc_id), offset) => {
-                        (ecx.tcx.global_alloc(alloc_id).unwrap_memory(), offset.bytes())
-                    }
-                    (None, _offset) => (
-                        ecx.tcx.mk_const_alloc(Allocation::from_bytes_byte_aligned_immutable(
-                            b"" as &[u8],
-                        )),
-                        0,
-                    ),
-                };
-                let len = b.to_target_usize(ecx).unwrap();
-                let start = start.try_into().unwrap();
-                let len: usize = len.try_into().unwrap();
-                ConstValue::Slice { data, start, end: start + len }
+            Immediate::ScalarPair(..) => {
+                let place = ecx.allocate(imm.layout, MemoryKind::Stack).unwrap();
+                ecx.write_immediate(*imm, &place.into()).unwrap();
+                intern_const_alloc_recursive(ecx, InternKind::Constant, &place).unwrap();
+
+                to_const_value(&place)
             }
             Immediate::Uninit => to_const_value(&op.assert_mem_place()),
         },
@@ -202,8 +192,7 @@ pub(crate) fn turn_into_const_value<'tcx>(
     let cid = key.value;
     let def_id = cid.instance.def.def_id();
     let is_static = tcx.is_static(def_id);
-    // This is just accessing an already computed constant, so no need to check alignment here.
-    let ecx = mk_eval_cx(
+    let mut ecx = mk_eval_cx(
         tcx,
         tcx.def_span(key.value.instance.def_id()),
         key.param_env,
@@ -220,7 +209,7 @@ pub(crate) fn turn_into_const_value<'tcx>(
     );
 
     // Turn this into a proper constant.
-    op_to_const(&ecx, &mplace.into())
+    op_to_const(&mut ecx, &mplace.into())
 }
 
 #[instrument(skip(tcx), level = "debug")]

compiler/rustc_const_eval/src/const_eval/mod.rs

@@ -2,10 +2,10 @@
 
 use crate::errors::MaxNumNodesInConstErr;
 use crate::interpret::{
-    intern_const_alloc_recursive, ConstValue, InternKind, InterpCx, InterpResult, Scalar,
+    intern_const_alloc_recursive, ConstValue, ImmTy, InternKind, InterpCx, InterpResult, Scalar,
 };
 use rustc_middle::mir;
-use rustc_middle::mir::interpret::{EvalToValTreeResult, GlobalId};
+use rustc_middle::mir::interpret::{ConstAllocation, EvalToValTreeResult, GlobalId};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::{source_map::DUMMY_SP, symbol::Symbol};
 
@@ -91,7 +91,7 @@ pub(crate) fn try_destructure_mir_constant<'tcx>(
     val: mir::ConstantKind<'tcx>,
 ) -> InterpResult<'tcx, mir::DestructuredConstant<'tcx>> {
     trace!("destructure_mir_constant: {:?}", val);
-    let ecx = mk_eval_cx(tcx, DUMMY_SP, param_env, false);
+    let mut ecx = mk_eval_cx(tcx, DUMMY_SP, param_env, false);
     let op = ecx.eval_mir_constant(&val, None, None)?;
 
     // We go to `usize` as we cannot allocate anything bigger anyway.
@@ -112,11 +112,30 @@ pub(crate) fn try_destructure_mir_constant<'tcx>(
     let fields_iter = (0..field_count)
         .map(|i| {
             let field_op = ecx.operand_field(&down, i)?;
-            let val = op_to_const(&ecx, &field_op);
+            let val = op_to_const(&mut ecx, &field_op);
             Ok(mir::ConstantKind::Val(val, field_op.layout.ty))
         })
         .collect::<InterpResult<'tcx, Vec<_>>>()?;
     let fields = tcx.arena.alloc_from_iter(fields_iter);
 
     Ok(mir::DestructuredConstant { variant, fields })
 }
+
+/// Creates an `&[u8]` slice pointing to the given allocation
+/// (covering it entirely, i.e., the length is the allocation size).
+pub fn slice_for_alloc<'tcx>(tcx: TyCtxt<'tcx>, alloc: ConstAllocation<'tcx>) -> ConstValue<'tcx> {
+    let alloc_id = tcx.create_memory_alloc(alloc);
+
+    let a = Scalar::from_pointer(alloc_id.into(), &tcx);
+    let b = Scalar::from_target_usize(alloc.0.size().bytes(), &tcx);
+    let imm = crate::interpret::Immediate::ScalarPair(a, b);
+    let mut ecx = mk_eval_cx(tcx, DUMMY_SP, ty::ParamEnv::reveal_all(), false);
+
+    let layout = tcx
+        .layout_of(
+            ty::ParamEnv::reveal_all()
+                .and(tcx.mk_imm_ref(tcx.lifetimes.re_static, tcx.mk_slice(tcx.types.u8))),
+        )
+        .unwrap();
+    op_to_const(&mut ecx, &ImmTy::from_immediate(imm, layout).into())
+}

compiler/rustc_const_eval/src/const_eval/valtrees.rs

@@ -296,9 +296,9 @@ pub fn valtree_to_const_value<'tcx>(
                     let imm =
                         ImmTy::from_immediate(ref_place, tcx.layout_of(param_env_ty).unwrap());
 
-                    op_to_const(&ecx, &imm.into())
+                    op_to_const(&mut ecx, &imm.into())
                 }
-                _ => op_to_const(&ecx, &place.into()),
+                _ => op_to_const(&mut ecx, &place.into()),
             }
         }
         ty::Never

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -5,9 +5,7 @@
 use rustc_hir::def_id::DefId;
 use rustc_middle::mir::{
     self,
-    interpret::{
-        Allocation, ConstAllocation, ConstValue, GlobalId, InterpResult, PointerArithmetic, Scalar,
-    },
+    interpret::{Allocation, ConstValue, GlobalId, InterpResult, PointerArithmetic, Scalar},
     BinOp, NonDivergingIntrinsic,
 };
 use rustc_middle::ty;
@@ -17,6 +15,8 @@ use rustc_middle::ty::{Ty, TyCtxt};
 use rustc_span::symbol::{sym, Symbol};
 use rustc_target::abi::{Abi, Align, Primitive, Size};
 
+use crate::const_eval::slice_for_alloc;
+
 use super::{
     util::ensure_monomorphic_enough, CheckInAllocMsg, ImmTy, InterpCx, Machine, OpTy, PlaceTy,
     Pointer,
@@ -44,10 +44,10 @@ fn numeric_intrinsic<Prov>(name: Symbol, bits: u128, kind: Primitive) -> Scalar<
 }
 
 /// Directly returns an `Allocation` containing an absolute path representation of the given type.
-pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAllocation<'tcx> {
+pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstValue<'tcx> {
     let path = crate::util::type_name(tcx, ty);
     let alloc = Allocation::from_bytes_byte_aligned_immutable(path.into_bytes());
-    tcx.mk_const_alloc(alloc)
+    slice_for_alloc(tcx, tcx.mk_const_alloc(alloc))
 }
 
 /// The logic for all nullary intrinsics is implemented here. These intrinsics don't get evaluated
@@ -63,8 +63,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
     Ok(match name {
         sym::type_name => {
             ensure_monomorphic_enough(tcx, tp_ty)?;
-            let alloc = alloc_type_name(tcx, tp_ty);
-            ConstValue::Slice { data: alloc, start: 0, end: alloc.inner().len() }
+            alloc_type_name(tcx, tp_ty)
         }
         sym::needs_drop => {
             ensure_monomorphic_enough(tcx, tp_ty)?;

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -657,19 +657,6 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             }
             ConstValue::Scalar(x) => Operand::Immediate(adjust_scalar(x)?.into()),
             ConstValue::ZeroSized => Operand::Immediate(Immediate::Uninit),
-            ConstValue::Slice { data, start, end } => {
-                // We rely on mutability being set correctly in `data` to prevent writes
-                // where none should happen.
-                let ptr = Pointer::new(
-                    self.tcx.create_memory_alloc(data),
-                    Size::from_bytes(start), // offset: `start`
-                );
-                Operand::Immediate(Immediate::new_slice(
-                    Scalar::from_pointer(self.global_base_pointer(ptr)?, &*self.tcx),
-                    u64::try_from(end.checked_sub(start).unwrap()).unwrap(), // len: `end - start`
-                    self,
-                ))
-            }
         };
         Ok(OpTy { op, layout, align: Some(layout.align.abi) })
     }

compiler/rustc_middle/src/mir/interpret/mod.rs

@@ -149,7 +149,7 @@ pub use self::error::{
     ValidationErrorInfo, ValidationErrorKind,
 };
 
-pub use self::value::{get_slice_bytes, ConstAlloc, ConstValue, Scalar};
+pub use self::value::{ConstAlloc, ConstValue, Scalar};
 
 pub use self::allocation::{
     alloc_range, AllocBytes, AllocError, AllocRange, AllocResult, Allocation, ConstAllocation,

compiler/rustc_middle/src/mir/interpret/value.rs

@@ -7,12 +7,13 @@ use rustc_apfloat::{
     Float,
 };
 use rustc_macros::HashStable;
+use rustc_span::Span;
 use rustc_target::abi::{HasDataLayout, Size};
 
 use crate::ty::{ParamEnv, ScalarInt, Ty, TyCtxt};
 
 use super::{
-    AllocId, AllocRange, ConstAllocation, InterpResult, Pointer, PointerArithmetic, Provenance,
+    AllocId, ConstAllocation, InterpResult, Pointer, PointerArithmetic, Provenance,
     ScalarSizeMismatch,
 };
 
@@ -25,7 +26,7 @@ pub struct ConstAlloc<'tcx> {
     pub ty: Ty<'tcx>,
 }
 
-/// Represents a constant value in Rust. `Scalar` and `Slice` are optimizations for
+/// Represents a constant value in Rust. `Scalar` is an optimization for
 /// array length computations, enum discriminants and the pattern matching logic.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, TyEncodable, TyDecodable, Hash)]
 #[derive(HashStable, Lift)]
@@ -38,9 +39,6 @@ pub enum ConstValue<'tcx> {
     /// Only used for ZSTs.
     ZeroSized,
 
-    /// Used only for `&[u8]` and `&str`
-    Slice { data: ConstAllocation<'tcx>, start: usize, end: usize },
-
     /// A value not represented/representable by `Scalar` or `Slice`
     ByRef {
         /// The backing memory of the value, may contain more memory than needed for just the value
@@ -52,13 +50,46 @@ pub enum ConstValue<'tcx> {
 }
 
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-static_assert_size!(ConstValue<'_>, 32);
+static_assert_size!(ConstValue<'_>, 24);
 
 impl<'tcx> ConstValue<'tcx> {
+    pub fn expect_slice(self, tcx: TyCtxt<'tcx>, span: Span) -> &'tcx [u8] {
+        let ConstValue::ByRef { alloc, offset } = self else {
+            span_bug!(span, "invalid string constant: {self:?}")
+        };
+        assert_eq!(offset, Size::ZERO);
+        let ptr_size = tcx.data_layout.pointer_size;
+        let (alloc_id, offset) = alloc
+            .0
+            .read_scalar(&tcx, Size::ZERO..ptr_size, true)
+            .unwrap()
+            .to_pointer(&tcx)
+            .unwrap()
+            .into_parts();
+        let len = alloc
+            .0
+            .read_scalar(&tcx, ptr_size..(ptr_size * 2), true)
+            .unwrap()
+            .assert_bits(ptr_size);
+        match (alloc_id, len) {
+            (_, 0) => b"",
+            (None, _) => {
+                span_bug!(span, "string with {len} bytes but no alloc id")
+            }
+            (Some(alloc_id), _) => {
+                let alloc = tcx.global_alloc(alloc_id).unwrap_memory();
+                alloc
+                    .inner()
+                    .get_bytes_strip_provenance(&tcx, offset..(offset + Size::from_bytes(len)))
+                    .unwrap()
+            }
+        }
+    }
+
     #[inline]
     pub fn try_to_scalar(&self) -> Option<Scalar<AllocId>> {
         match *self {
-            ConstValue::ByRef { .. } | ConstValue::Slice { .. } | ConstValue::ZeroSized => None,
+            ConstValue::ByRef { .. } | ConstValue::ZeroSized => None,
             ConstValue::Scalar(val) => Some(val),
         }
     }
@@ -323,6 +354,13 @@ impl<Prov> Scalar<Prov> {
 }
 
 impl<'tcx, Prov: Provenance> Scalar<Prov> {
+    pub fn size(self) -> Size {
+        match self {
+            Scalar::Int(s) => s.size(),
+            Scalar::Ptr(_, size) => Size::from_bytes(size),
+        }
+    }
+
     pub fn to_pointer(self, cx: &impl HasDataLayout) -> InterpResult<'tcx, Pointer<Option<Prov>>> {
         match self
             .to_bits_or_ptr_internal(cx.pointer_size())
@@ -496,18 +534,3 @@ impl<'tcx, Prov: Provenance> Scalar<Prov> {
         Ok(Double::from_bits(self.to_u64()?.into()))
     }
 }
-
-/// Gets the bytes of a constant slice value.
-pub fn get_slice_bytes<'tcx>(cx: &impl HasDataLayout, val: ConstValue<'tcx>) -> &'tcx [u8] {
-    if let ConstValue::Slice { data, start, end } = val {
-        let len = end - start;
-        data.inner()
-            .get_bytes_strip_provenance(
-                cx,
-                AllocRange { start: Size::from_bytes(start), size: Size::from_bytes(len) },
-            )
-            .unwrap_or_else(|err| bug!("const slice is invalid: {:?}", err))
-    } else {
-        bug!("expected const slice, but found another const value");
-    }
-}