Rollup merge of rust-lang#64419 - wesleywiser:const_prop_use_ecx, r=oli-obk

Deduplicate some code between miri and const prop

r? @oli-obk

Author: Centril

src/librustc/mir/interpret/error.rs

@@ -393,6 +393,7 @@ pub enum UnsupportedOpInfo<'tcx> {
     InvalidPointerMath,
     ReadUndefBytes(Size),
     DeadLocal,
+    UninitializedLocal,
     InvalidBoolOp(mir::BinOp),
     UnimplementedTraitSelection,
     CalledClosureAsFunction,
@@ -420,6 +421,7 @@ pub enum UnsupportedOpInfo<'tcx> {
     HeapAllocNonPowerOfTwoAlignment(u64),
     ReadFromReturnPointer,
     PathNotFound(Vec<String>),
+    ReadOfStaticInConst,
 }
 
 impl fmt::Debug for UnsupportedOpInfo<'tcx> {
@@ -491,6 +493,8 @@ impl fmt::Debug for UnsupportedOpInfo<'tcx> {
                     addresses, e.g., comparing pointers into different allocations"),
             DeadLocal =>
                 write!(f, "tried to access a dead local variable"),
+            UninitializedLocal =>
+                write!(f, "tried to access an uninitialized local variable"),
             DerefFunctionPointer =>
                 write!(f, "tried to dereference a function pointer"),
             ExecuteMemory =>
@@ -532,6 +536,8 @@ impl fmt::Debug for UnsupportedOpInfo<'tcx> {
                     not a power of two"),
             Unsupported(ref msg) =>
                 write!(f, "{}", msg),
+            ReadOfStaticInConst =>
+                write!(f, "tried to read from a static during const evaluation"),
         }
     }
 }

src/librustc_mir/interpret/eval_context.rs

@@ -136,7 +136,8 @@ impl<'tcx, Tag: Copy + 'static> LocalState<'tcx, Tag> {
         match self.value {
             LocalValue::Dead => throw_unsup!(DeadLocal),
             LocalValue::Uninitialized =>
-                bug!("The type checker should prevent reading from a never-written local"),
+                // this is reachable from ConstProp
+                throw_unsup!(UninitializedLocal),
             LocalValue::Live(val) => Ok(val),
         }
     }

src/librustc_mir/interpret/operand.rs

@@ -470,7 +470,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
     // Evaluate a place with the goal of reading from it.  This lets us sometimes
     // avoid allocations.
-    pub(super) fn eval_place_to_op(
+    pub fn eval_place_to_op(
         &self,
         place: &mir::Place<'tcx>,
         layout: Option<TyLayout<'tcx>>,

src/librustc_mir/interpret/place.rs

@@ -595,6 +595,14 @@ where
             }
 
             StaticKind::Static => {
+                //if the first frame on the stack isn't a static item, then we shouldn't
+                //eval any static places
+                if let ty::InstanceDef::Item(item_def_id) = self.stack[0].instance.def {
+                    if !self.tcx.is_static(item_def_id) {
+                        trace!("eval_static_to_mplace: can't eval static in constant");
+                        throw_unsup!(ReadOfStaticInConst);
+                    }
+                }
                 let ty = place_static.ty;
                 assert!(!ty.needs_subst());
                 let layout = self.layout_of(ty)?;

src/librustc_mir/interpret/step.rs

@@ -132,7 +132,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     ///
     /// There is no separate `eval_rvalue` function. Instead, the code for handling each rvalue
     /// type writes its results directly into the memory specified by the place.
-    fn eval_rvalue_into_place(
+    pub fn eval_rvalue_into_place(
         &mut self,
         rvalue: &mir::Rvalue<'tcx>,
         place: &mir::Place<'tcx>,