Fixup a bunch of things for "simplify const value"

Author: oli-obk

src/librustc_mir/interpret/operand.rs

@@ -14,7 +14,7 @@
 use std::convert::TryInto;
 
 use rustc::mir;
-use rustc::ty::layout::{self, Size, TyLayout, HasDataLayout, IntegerExt};
+use rustc::ty::layout::{self, Size, LayoutOf, TyLayout, HasDataLayout, IntegerExt};
 
 use rustc::mir::interpret::{
     AllocId,
@@ -338,7 +338,7 @@ impl<'tcx, Tag> OpTy<'tcx, Tag>
 // Use the existing layout if given (but sanity check in debug mode),
 // or compute the layout.
 #[inline(always)]
-fn from_known_layout<'tcx>(
+pub(super) fn from_known_layout<'tcx>(
     layout: Option<TyLayout<'tcx>>,
     compute: impl FnOnce() -> EvalResult<'tcx, TyLayout<'tcx>>
 ) -> EvalResult<'tcx, TyLayout<'tcx>> {
@@ -628,7 +628,12 @@ impl<'a, 'mir, 'tcx, M: Machine<'a, 'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M>
                 self.eval_place_to_op(place, layout)?,
 
             Constant(ref constant) => {
-                self.const_to_mplace(constant.literal)?.into()
+                let layout = super::operand::from_known_layout(layout, || {
+                    let ty = self.monomorphize(mir_op.ty(self.mir(), *self.tcx), self.substs());
+                    self.layout_of(ty)
+                })?;
+                let op = Operand::Indirect(self.const_value_to_mplace(constant.literal.val)?);
+                OpTy { op, layout }
             }
         };
         trace!("{:?}: {:?}", mir_op, *op);

src/librustc_mir/interpret/place.rs

@@ -527,34 +527,41 @@ where
     }
 
     // Also used e.g. when miri runs into a constant.
-    pub fn const_to_mplace(
+    pub fn const_value_to_mplace(
         &self,
-        val: &ty::Const<'tcx>,
-    ) -> EvalResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> {
+        val: ConstValue<'tcx>,
+    ) -> EvalResult<'tcx, MemPlace<M::PointerTag>> {
         trace!("const_value_to_mplace: {:?}", val);
-        let mplace = match val.val {
+        match val {
             ConstValue::Unevaluated(def_id, substs) => {
                 let instance = self.resolve(def_id, substs)?;
                 self.global_to_mplace(GlobalId {
                     instance,
                     promoted: None,
-                })?
+                })
             }
             ConstValue::ByRef(id, alloc, offset) => {
                 // We rely on mutability being set correctly in that allocation to prevent writes
                 // where none should happen -- and for `static mut`, we copy on demand anyway.
-                MemPlace::from_ptr(Pointer::new(id, offset), alloc.align).with_default_tag()
+                Ok(MemPlace::from_ptr(Pointer::new(id, offset), alloc.align).with_default_tag())
             }
-        };
-        Ok(MPlaceTy { mplace, layout: self.layout_of(val.ty)? })
+        }
+    }
+
+    pub fn const_to_mplace(
+        &self,
+        cnst: &ty::Const<'tcx>,
+    ) -> EvalResult<'tcx, MPlaceTy<'tcx, M::PointerTag>> {
+        let mplace = self.const_value_to_mplace(cnst.val)?;
+        Ok(MPlaceTy { mplace, layout: self.layout_of(cnst.ty)? })
     }
 
     fn global_to_mplace(
         &self,
         gid: GlobalId<'tcx>
     ) -> EvalResult<'tcx, MemPlace<M::PointerTag>> {
         let cv = self.const_eval(gid)?;
-        Ok(*self.const_to_mplace(cv)?)
+        self.const_value_to_mplace(cv.val)
     }
 
     /// Evaluate statics and promoteds to an `MPlace`.  Used to share some code between