Use `read_local_of_frame` in `eval_place_to_op`

Also make `layout_of_local` accept any `Frame`

src/librustc_mir/interpret/eval_context.rs

@@ -324,14 +324,11 @@ pub fn monomorphize<T: TypeFoldable<'tcx> + Subst<'tcx>>(
 
     pub fn layout_of_local(
         &self,
-        frame: usize,
+        frame: &Frame<'mir, 'tcx, M::PointerTag>,
         local: mir::Local
     ) -> EvalResult<'tcx, TyLayout<'tcx>> {
-        let local_ty = self.stack[frame].mir.local_decls[local].ty;
-        let local_ty = self.monomorphize(
-            local_ty,
-            self.stack[frame].instance.substs
-        );
+        let local_ty = frame.mir.local_decls[local].ty;
+        let local_ty = self.monomorphize(local_ty, frame.instance.substs);
         self.layout_of(local_ty)
     }
 
@@ -579,7 +576,7 @@ pub fn storage_live(
         assert!(local != mir::RETURN_PLACE, "Cannot make return place live");
         trace!("{:?} is now live", local);
 
-        let layout = self.layout_of_local(self.cur_frame(), local)?;
+        let layout = self.layout_of_local(self.frame(), local)?;
         let init = LocalValue::Live(self.uninit_operand(layout)?);
         // StorageLive *always* kills the value that's currently stored
         Ok(mem::replace(&mut self.frame_mut().locals[local], init))
@@ -733,4 +730,3 @@ pub fn truncate(&self, value: u128, ty: TyLayout<'_>) -> u128 {
         truncate(value, ty.size)
     }
 }
-

src/librustc_mir/interpret/operand.rs

@@ -571,6 +571,19 @@ pub fn operand_projection(
         })
     }
 
+    /// This is used by [priroda](https://github.com/oli-obk/priroda) to get an OpTy from a local
+    pub fn read_local_of_frame(
+        &self,
+        frame: &super::Frame<'mir, 'tcx, M::PointerTag>,
+        local: mir::Local,
+        layout: Option<TyLayout<'tcx>>,
+    ) -> EvalResult<'tcx, OpTy<'tcx, M::PointerTag>> {
+        let op = *frame.locals[local].access()?;
+        let layout = from_known_layout(layout,
+                    || self.layout_of_local(frame, local))?;
+        Ok(OpTy { op, layout })
+    }
+
     // Evaluate a place with the goal of reading from it.  This lets us sometimes
     // avoid allocations.  If you already know the layout, you can pass it in
     // to avoid looking it up again.
@@ -582,12 +595,7 @@ fn eval_place_to_op(
         use rustc::mir::Place::*;
         let op = match *mir_place {
             Local(mir::RETURN_PLACE) => return err!(ReadFromReturnPointer),
-            Local(local) => {
-                let op = *self.frame().locals[local].access()?;
-                let layout = from_known_layout(layout,
-                    || self.layout_of_local(self.cur_frame(), local))?;
-                OpTy { op, layout }
-            },
+            Local(local) => self.read_local_of_frame(self.frame(), local, layout)?,
 
             Projection(ref proj) => {
                 let op = self.eval_place_to_op(&proj.base, None)?;
@@ -772,16 +780,4 @@ pub fn read_discriminant(
         })
     }
 
-    /// This is used by [priroda](https://github.com/oli-obk/priroda) to get an OpTy from a local
-    pub fn read_local_of_frame(
-        &self,
-        frame: &super::Frame<'mir, 'tcx>,
-        local: mir::Local
-    ) -> EvalResult<'tcx, OpTy<'tcx>> {
-        let op = *frame.locals[local].access()?;
-        let local_ty = frame.mir.local_decls[local].ty;
-        let local_ty = self.monomorphize(local_ty, frame.instance.substs);
-        let layout = self.layout_of(local_ty)?;
-        Ok(OpTy { op, layout })
-    }
 }

src/librustc_mir/interpret/place.rs

@@ -588,7 +588,7 @@ pub fn eval_place(
                     // their layout on return.
                     PlaceTy {
                         place: *return_place,
-                        layout: self.layout_of_local(self.cur_frame(), mir::RETURN_PLACE)?,
+                        layout: self.layout_of_local(self.frame(), mir::RETURN_PLACE)?,
                     },
                 None => return err!(InvalidNullPointerUsage),
             },
@@ -597,7 +597,7 @@ pub fn eval_place(
                     frame: self.cur_frame(),
                     local,
                 },
-                layout: self.layout_of_local(self.cur_frame(), local)?,
+                layout: self.layout_of_local(self.frame(), local)?,
             },
 
             Projection(ref proj) => {
@@ -856,7 +856,7 @@ pub fn force_allocation(
                         // We need the layout of the local.  We can NOT use the layout we got,
                         // that might e.g. be an inner field of a struct with `Scalar` layout,
                         // that has different alignment than the outer field.
-                        let local_layout = self.layout_of_local(frame, local)?;
+                        let local_layout = self.layout_of_local(&self.stack[frame], local)?;
                         let ptr = self.allocate(local_layout, MemoryKind::Stack)?;
                         // We don't have to validate as we can assume the local
                         // was already valid for its type.

src/librustc_mir/interpret/terminator.rs

@@ -310,7 +310,7 @@ fn eval_fn_call(
                         mir.spread_arg,
                         mir.args_iter()
                             .map(|local|
-                                (local, self.layout_of_local(self.cur_frame(), local).unwrap().ty)
+                                (local, self.layout_of_local(self.frame(), local).unwrap().ty)
                             )
                             .collect::<Vec<_>>()
                     );
@@ -380,7 +380,7 @@ fn eval_fn_call(
                         }
                     } else {
                         let callee_layout =
-                            self.layout_of_local(self.cur_frame(), mir::RETURN_PLACE)?;
+                            self.layout_of_local(self.frame(), mir::RETURN_PLACE)?;
                         if !callee_layout.abi.is_uninhabited() {
                             return err!(FunctionRetMismatch(
                                 self.tcx.types.never, callee_layout.ty