Setup ty::Const to allow ConstValue::Scalar to be backed by an allocation

Author: oli-obk

src/librustc/ich/impls_ty.rs

@@ -300,12 +300,13 @@ impl_stable_hash_for!(struct ty::FieldDef {
 });
 
 impl_stable_hash_for!(
-    impl<'tcx> for enum mir::interpret::ConstValue<'tcx> [ mir::interpret::ConstValue ] {
+    impl<'tcx> for enum mir::interpret::ConstValue [ mir::interpret::ConstValue ] {
         Scalar(val),
         Slice(a, b),
-        ByRef(id, alloc, offset),
+        ByRef,
     }
 );
+
 impl_stable_hash_for!(struct crate::mir::interpret::RawConst<'tcx> {
     alloc_id,
     ty,
@@ -374,6 +375,7 @@ impl_stable_hash_for!(enum ::syntax::ast::Mutability {
 
 impl_stable_hash_for!(struct ty::Const<'tcx> {
     ty,
+    alloc,
     val
 });
 

src/librustc/mir/interpret/value.rs

@@ -2,7 +2,7 @@ use std::fmt;
 
 use crate::ty::{Ty, layout::{HasDataLayout, Size}};
 
-use super::{EvalResult, Pointer, PointerArithmetic, Allocation, AllocId, sign_extend, truncate};
+use super::{EvalResult, Pointer, PointerArithmetic, AllocId, sign_extend, truncate};
 
 /// Represents the result of a raw const operation, pre-validation.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, RustcEncodable, RustcDecodable, Hash)]
@@ -16,7 +16,7 @@ pub struct RawConst<'tcx> {
 /// Represents a constant value in Rust. `Scalar` and `ScalarPair` are optimizations that
 /// match the `LocalState` optimizations for easy conversions between `Value` and `ConstValue`.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd, Ord, RustcEncodable, RustcDecodable, Hash)]
-pub enum ConstValue<'tcx> {
+pub enum ConstValue {
     /// Used only for types with `layout::abi::Scalar` ABI and ZSTs.
     ///
     /// Not using the enum `Value` to encode that this must not be `Undef`.
@@ -31,19 +31,17 @@ pub enum ConstValue<'tcx> {
     /// it.
     Slice(Scalar, u64),
 
-    /// An allocation together with an offset into the allocation.
-    /// Invariant: the `AllocId` matches the allocation.
-    ByRef(AllocId, &'tcx Allocation, Size),
+    ByRef,
 }
 
 #[cfg(target_arch = "x86_64")]
-static_assert!(CONST_SIZE: ::std::mem::size_of::<ConstValue<'static>>() == 40);
+static_assert!(CONST_SIZE: ::std::mem::size_of::<ConstValue>() == 40);
 
-impl<'tcx> ConstValue<'tcx> {
+impl ConstValue {
     #[inline]
     pub fn try_to_scalar(&self) -> Option<Scalar> {
         match *self {
-            ConstValue::ByRef(..) |
+            ConstValue::ByRef |
             ConstValue::Slice(..) => None,
             ConstValue::Scalar(val) => Some(val),
         }

src/librustc/mir/mod.rs

@@ -1665,6 +1665,7 @@ impl<'tcx> TerminatorKind<'tcx> {
                                 }.into(),
                             ),
                             ty: switch_ty,
+                            alloc: None,
                         };
                         fmt_const_val(&mut s, c).unwrap();
                         s.into()

src/librustc/ty/structural_impls.rs

@@ -4,7 +4,6 @@
 //! `BraceStructLiftImpl!`) to help with the tedium.
 
 use crate::mir::ProjectionKind;
-use crate::mir::interpret::ConstValue;
 use crate::ty::{self, Lift, Ty, TyCtxt};
 use crate::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
 use rustc_data_structures::indexed_vec::{IndexVec, Idx};
@@ -486,23 +485,20 @@ BraceStructLiftImpl! {
     }
 }
 
-BraceStructLiftImpl! {
-    impl<'a, 'tcx> Lift<'tcx> for ty::Const<'a> {
-        type Lifted = ty::Const<'tcx>;
-        val, ty
-    }
-}
-
-impl<'a, 'tcx> Lift<'tcx> for ConstValue<'a> {
-    type Lifted = ConstValue<'tcx>;
+impl<'a, 'tcx> Lift<'tcx> for ty::Const<'a> {
+    type Lifted = ty::Const<'tcx>;
     fn lift_to_tcx<'b, 'gcx>(&self, tcx: TyCtxt<'b, 'gcx, 'tcx>) -> Option<Self::Lifted> {
-        match *self {
-            ConstValue::Scalar(x) => Some(ConstValue::Scalar(x)),
-            ConstValue::Slice(x, y) => Some(ConstValue::Slice(x, y)),
-            ConstValue::ByRef(x, alloc, z) => Some(ConstValue::ByRef(
-                x, alloc.lift_to_tcx(tcx)?, z,
-            )),
-        }
+        let ty = self.ty.lift_to_tcx(tcx)?;
+        let alloc = match self.alloc {
+            // can't use `and_then` or `map`, because the inner `lift_to_tcx` needs to early return
+            Some((a, p)) => Some((a.lift_to_tcx(tcx)?, p)),
+            None => None,
+        };
+        Some(ty::Const {
+            val: self.val,
+            ty,
+            alloc,
+        })
     }
 }
 
@@ -1064,24 +1060,14 @@ impl<'tcx> TypeFoldable<'tcx> for &'tcx ty::LazyConst<'tcx> {
 impl<'tcx> TypeFoldable<'tcx> for ty::Const<'tcx> {
     fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, folder: &mut F) -> Self {
         let ty = self.ty.fold_with(folder);
-        let val = self.val.fold_with(folder);
         ty::Const {
             ty,
-            val
+            val: self.val,
+            alloc: self.alloc,
         }
     }
 
     fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
-        self.ty.visit_with(visitor) || self.val.visit_with(visitor)
-    }
-}
-
-impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {
-    fn super_fold_with<'gcx: 'tcx, F: TypeFolder<'gcx, 'tcx>>(&self, _folder: &mut F) -> Self {
-        *self
-    }
-
-    fn super_visit_with<V: TypeVisitor<'tcx>>(&self, _visitor: &mut V) -> bool {
-        false
+        self.ty.visit_with(visitor)
     }
 }

src/librustc/ty/sty.rs

@@ -11,7 +11,7 @@ use crate::ty::subst::{Substs, Subst, Kind, UnpackedKind};
 use crate::ty::{self, AdtDef, TypeFlags, Ty, TyCtxt, TypeFoldable};
 use crate::ty::{List, TyS, ParamEnvAnd, ParamEnv};
 use crate::util::captures::Captures;
-use crate::mir::interpret::{Scalar, Pointer};
+use crate::mir::interpret::{Scalar, Pointer, Allocation};
 
 use smallvec::SmallVec;
 use std::iter;
@@ -2065,7 +2065,7 @@ pub enum LazyConst<'tcx> {
 }
 
 #[cfg(target_arch = "x86_64")]
-static_assert!(LAZY_CONST_SIZE: ::std::mem::size_of::<LazyConst<'static>>() == 56);
+static_assert!(LAZY_CONST_SIZE: ::std::mem::size_of::<LazyConst<'static>>() == 80);
 
 impl<'tcx> LazyConst<'tcx> {
     pub fn map_evaluated<R>(self, f: impl FnOnce(Const<'tcx>) -> Option<R>) -> Option<R> {
@@ -2090,11 +2090,22 @@ impl<'tcx> LazyConst<'tcx> {
 pub struct Const<'tcx> {
     pub ty: Ty<'tcx>,
 
-    pub val: ConstValue<'tcx>,
+    /// This field is an optimization for caching commonly needed values of constants like `usize`
+    /// (or other integers for enum discriminants) and slices (e.g. from `b"foo"` and `"foo"`
+    /// literals)
+    pub val: ConstValue,
+
+    /// The actual backing storage of the constant and a pointer which can be resolved back to the
+    /// `allocation` field
+    ///
+    /// Can be `None` for trivial constants created from literals or directly. Is always `Some` for
+    /// aggregate constants or any named constant that you can actually end up taking a reference
+    /// to. This will get unwrapped in situations where we do know that it's a referencable
+    pub alloc: Option<(&'tcx Allocation, Pointer)>,
 }
 
 #[cfg(target_arch = "x86_64")]
-static_assert!(CONST_SIZE: ::std::mem::size_of::<Const<'static>>() == 48);
+static_assert!(CONST_SIZE: ::std::mem::size_of::<Const<'static>>() == 72);
 
 impl<'tcx> Const<'tcx> {
     #[inline]
@@ -2105,6 +2116,7 @@ impl<'tcx> Const<'tcx> {
         Self {
             val: ConstValue::Scalar(val),
             ty,
+            alloc: None,
         }
     }
 

src/librustc_codegen_llvm/consts.rs

@@ -69,11 +69,12 @@ pub fn codegen_static_initializer(
     };
     let param_env = ty::ParamEnv::reveal_all();
     let static_ = cx.tcx.const_eval(param_env.and(cid))?;
-
-    let alloc = match static_.val {
-        ConstValue::ByRef(_, alloc, n) if n.bytes() == 0 => alloc,
+    let (alloc, ptr) = static_.alloc.unwrap();
+    assert_eq!(ptr.offset.bytes(), 0);
+    match static_.val {
+        ConstValue::ByRef => {},
         _ => bug!("static const eval returned {:#?}", static_),
-    };
+    }
     Ok((const_alloc_to_llvm(cx, alloc), alloc))
 }
 

src/librustc_codegen_ssa/mir/operand.rs

@@ -101,8 +101,9 @@ impl<'a, 'tcx: 'a, V: CodegenObject> OperandRef<'tcx, V> {
                 let b_llval = bx.cx().const_usize(b);
                 OperandValue::Pair(a_llval, b_llval)
             },
-            ConstValue::ByRef(_, alloc, offset) => {
-                return Ok(bx.load_operand(bx.cx().from_const_alloc(layout, alloc, offset)));
+            ConstValue::ByRef => {
+                let (alloc, ptr) = val.alloc.unwrap();
+                return Ok(bx.load_operand(bx.cx().from_const_alloc(layout, alloc, ptr.offset)));
             },
         };
 

src/librustc_codegen_ssa/mir/place.rs

@@ -417,8 +417,9 @@ impl<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let layout = cx.layout_of(self.monomorphize(&ty));
                 match bx.tcx().const_eval(param_env.and(cid)) {
                     Ok(val) => match val.val {
-                        mir::interpret::ConstValue::ByRef(_, alloc, offset) => {
-                            bx.cx().from_const_alloc(layout, alloc, offset)
+                        mir::interpret::ConstValue::ByRef => {
+                            let (alloc, ptr) = val.alloc.unwrap();
+                            bx.cx().from_const_alloc(layout, alloc, ptr.offset)
                         }
                         _ => bug!("promoteds should have an allocation: {:?}", val),
                     },

src/librustc_mir/const_eval.rs

@@ -83,7 +83,7 @@ pub fn op_to_const<'tcx>(
             Operand::Immediate(val) => Ok(val)
         }
     };
-    let val = match normalized_op {
+    let (val, alloc) = match normalized_op {
         Err(MemPlace { ptr, align, meta }) => {
             // extract alloc-offset pair
             assert!(meta.is_none());
@@ -96,14 +96,14 @@ pub fn op_to_const<'tcx>(
             // FIXME shouldn't it be the case that `mark_static_initialized` has already
             // interned this?  I thought that is the entire point of that `FinishStatic` stuff?
             let alloc = ecx.tcx.intern_const_alloc(alloc);
-            ConstValue::ByRef(ptr.alloc_id, alloc, ptr.offset)
+            (ConstValue::ByRef, Some((alloc, ptr)))
         },
         Ok(Immediate::Scalar(x)) =>
-            ConstValue::Scalar(x.not_undef()?),
+            (ConstValue::Scalar(x.not_undef()?), None),
         Ok(Immediate::ScalarPair(a, b)) =>
-            ConstValue::Slice(a.not_undef()?, b.to_usize(ecx)?),
+            (ConstValue::Slice(a.not_undef()?, b.to_usize(ecx)?), None),
     };
-    Ok(ty::Const { val, ty: op.layout.ty })
+    Ok(ty::Const { val, ty: op.layout.ty, alloc })
 }
 
 fn eval_body_and_ecx<'a, 'mir, 'tcx>(

src/librustc_mir/hair/constant.rs

@@ -42,6 +42,7 @@ crate fn lit_to_const<'a, 'gcx, 'tcx>(
             let id = tcx.allocate_bytes(s.as_bytes());
             return Ok(ty::Const {
                 val: ConstValue::new_slice(Scalar::Ptr(id.into()), s.len() as u64),
+                alloc: None,
                 ty: tcx.types.err,
             });
         },
@@ -72,14 +73,14 @@ crate fn lit_to_const<'a, 'gcx, 'tcx>(
         LitKind::Bool(b) => ConstValue::Scalar(Scalar::from_bool(b)),
         LitKind::Char(c) => ConstValue::Scalar(Scalar::from_char(c)),
     };
-    Ok(ty::Const { val: lit, ty })
+    Ok(ty::Const { val: lit, ty, alloc: None })
 }
 
 fn parse_float<'tcx>(
     num: Symbol,
     fty: ast::FloatTy,
     neg: bool,
-) -> Result<ConstValue<'tcx>, ()> {
+) -> Result<ConstValue, ()> {
     let num = num.as_str();
     use rustc_apfloat::ieee::{Single, Double};
     use rustc_apfloat::Float;