Fiddle the corresponding allocation through all RawConst uses

Author: oli-obk

src/librustc/ich/impls_ty.rs

@@ -308,8 +308,10 @@ impl_stable_hash_for!(
 );
 
 impl_stable_hash_for!(struct crate::mir::interpret::RawConst<'tcx> {
+    // FIXME(oli-obk): is ignoring the `alloc_id` for perf reasons ok?
     alloc_id,
     ty,
+    alloc,
 });
 
 impl_stable_hash_for! {

src/librustc/mir/interpret/value.rs

@@ -2,15 +2,18 @@ use std::fmt;
 
 use crate::ty::{Ty, layout::{HasDataLayout, Size}};
 
-use super::{EvalResult, Pointer, PointerArithmetic, AllocId, sign_extend, truncate};
+use super::{EvalResult, Pointer, PointerArithmetic, AllocId, sign_extend, truncate, Allocation};
 
 /// Represents the result of a raw const operation, pre-validation.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, RustcEncodable, RustcDecodable, Hash)]
 pub struct RawConst<'tcx> {
-    // the value lives here, at offset 0, and that allocation definitely is a `AllocKind::Memory`
-    // (so you can use `AllocMap::unwrap_memory`).
+    /// the value lives here, at offset 0, and the allocation that it refers to is the one in the
+    /// `alloc` field
     pub alloc_id: AllocId,
     pub ty: Ty<'tcx>,
+    /// the allocation that would be returned by using
+    /// `tcx.alloc_map.lock().unwrap_memory(self.alloc_id)`
+    pub alloc: &'tcx Allocation,
 }
 
 /// Represents a constant value in Rust. `Scalar` and `ScalarPair` are optimizations that

src/librustc_mir/const_eval.rs

@@ -56,7 +56,7 @@ pub(crate) fn eval_promoted<'a, 'mir, 'tcx>(
     cid: GlobalId<'tcx>,
     mir: &'mir mir::Mir<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
-) -> EvalResult<'tcx, MPlaceTy<'tcx>> {
+) -> EvalResult<'tcx, (MPlaceTy<'tcx>, &'tcx Allocation)> {
     let span = tcx.def_span(cid.instance.def_id());
     let mut ecx = mk_eval_cx(tcx, span, param_env);
     eval_body_using_ecx(&mut ecx, cid, Some(mir), param_env)
@@ -111,7 +111,10 @@ fn eval_body_and_ecx<'a, 'mir, 'tcx>(
     cid: GlobalId<'tcx>,
     mir: Option<&'mir mir::Mir<'tcx>>,
     param_env: ty::ParamEnv<'tcx>,
-) -> (EvalResult<'tcx, MPlaceTy<'tcx>>, CompileTimeEvalContext<'a, 'mir, 'tcx>) {
+) -> (
+    EvalResult<'tcx, (MPlaceTy<'tcx>, &'tcx Allocation)>,
+    CompileTimeEvalContext<'a, 'mir, 'tcx>,
+) {
     // we start out with the best span we have
     // and try improving it down the road when more information is available
     let span = tcx.def_span(cid.instance.def_id());
@@ -127,7 +130,7 @@ fn eval_body_using_ecx<'mir, 'tcx>(
     cid: GlobalId<'tcx>,
     mir: Option<&'mir mir::Mir<'tcx>>,
     param_env: ty::ParamEnv<'tcx>,
-) -> EvalResult<'tcx, MPlaceTy<'tcx>> {
+) -> EvalResult<'tcx, (MPlaceTy<'tcx>, &'tcx Allocation)> {
     debug!("eval_body_using_ecx: {:?}, {:?}", cid, param_env);
     let tcx = ecx.tcx.tcx;
     let mut mir = match mir {
@@ -164,10 +167,10 @@ fn eval_body_using_ecx<'mir, 'tcx>(
     } else {
         Mutability::Immutable
     };
-    ecx.memory.intern_static(ret.ptr.to_ptr()?.alloc_id, mutability)?;
+    let alloc = ecx.memory.intern_static(ret.ptr.to_ptr()?.alloc_id, mutability)?;
 
     debug!("eval_body_using_ecx done: {:?}", *ret);
-    Ok(ret)
+    Ok((ret, alloc))
 }
 
 impl<'tcx> Into<EvalError<'tcx>> for ConstEvalError {
@@ -634,9 +637,10 @@ pub fn const_eval_raw_provider<'a, 'tcx>(
     };
 
     let (res, ecx) = eval_body_and_ecx(tcx, cid, None, key.param_env);
-    res.and_then(|place| {
+    res.and_then(|(place, alloc)| {
         Ok(RawConst {
             alloc_id: place.to_ptr().expect("we allocated this ptr!").alloc_id,
+            alloc,
             ty: place.layout.ty
         })
     }).map_err(|error| {

src/librustc_mir/interpret/memory.rs

@@ -621,7 +621,7 @@ where
         &mut self,
         alloc_id: AllocId,
         mutability: Mutability,
-    ) -> EvalResult<'tcx> {
+    ) -> EvalResult<'tcx, &'tcx Allocation> {
         trace!(
             "mark_static_initialized {:?}, mutability: {:?}",
             alloc_id,
@@ -647,15 +647,15 @@ where
             // does not permit code that would break this!
             if self.alloc_map.contains_key(&alloc) {
                 // Not yet interned, so proceed recursively
-                self.intern_static(alloc, mutability)?;
+                let _alloc = self.intern_static(alloc, mutability)?;
             } else if self.dead_alloc_map.contains_key(&alloc) {
                 // dangling pointer
                 return err!(ValidationFailure(
                     "encountered dangling pointer in final constant".into(),
                 ))
             }
         }
-        Ok(())
+        Ok(alloc)
     }
 }
 

src/librustc_mir/transform/const_prop.rs

@@ -296,7 +296,7 @@ impl<'a, 'mir, 'tcx> ConstPropagator<'a, 'mir, 'tcx> {
                 };
                 // cannot use `const_eval` here, because that would require having the MIR
                 // for the current function available, but we're producing said MIR right now
-                let res = self.use_ecx(source_info, |this| {
+                let (res, _) = self.use_ecx(source_info, |this| {
                     eval_promoted(this.tcx, cid, this.mir, this.param_env)
                 })?;
                 trace!("evaluated promoted {:?} to {:?}", promoted, res);