Support unwinding after a panic

Fixes rust-lang#658

This commit adds support for unwinding after a panic. It requires a
companion rustc PR to be merged, in order for the necessary hooks to
work properly.

Currently implemented:
* Selecting between unwind/abort mode based on the rustc Session
* Properly popping off stack frames, unwinding back the caller
* Running 'unwind' blocks in Mir terminators

Not yet implemented:
* 'Abort' terminators

This PR was getting fairly large, so I decided to open it for review without
implementing 'Abort' terminator support. This could either be added on
to this PR, or merged separately.

Author: Aaron1011

src/eval.rs

@@ -14,6 +14,8 @@ use crate::{
     TlsEvalContextExt,
 };
 
+use crate::machine::CachedTypes;
+
 /// Configuration needed to spawn a Miri instance.
 #[derive(Clone)]
 pub struct MiriConfig {
@@ -38,11 +40,8 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
     let mut ecx = InterpCx::new(
         tcx.at(syntax::source_map::DUMMY_SP),
         ty::ParamEnv::reveal_all(),
-        Evaluator::new(config.communicate),
-        MemoryExtra::new(
-            StdRng::seed_from_u64(config.seed.unwrap_or(0)),
-            config.validate,
-        ),
+        Evaluator::new(config.communicate, CachedTypes::new(tcx)?),
+        MemoryExtra::new(StdRng::seed_from_u64(config.seed.unwrap_or(0)), config.validate),
     );
     // Complete initialization.
     EnvVars::init(&mut ecx, config.excluded_env_vars);

src/helpers.rs

@@ -1,6 +1,6 @@
 use std::mem;
 
-use rustc::ty::{self, layout::{self, Size, Align}};
+use rustc::ty::{self, TyCtxt, layout::{self, Size, Align}};
 use rustc::hir::def_id::{DefId, CRATE_DEF_INDEX};
 use rustc::mir;
 
@@ -10,32 +10,31 @@ use crate::*;
 
 impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 
-pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
-    /// Gets an instance for a path.
-    fn resolve_path(&self, path: &[&str]) -> InterpResult<'tcx, ty::Instance<'tcx>> {
-        let this = self.eval_context_ref();
-        this.tcx
-            .crates()
-            .iter()
-            .find(|&&krate| this.tcx.original_crate_name(krate).as_str() == path[0])
-            .and_then(|krate| {
-                let krate = DefId {
-                    krate: *krate,
-                    index: CRATE_DEF_INDEX,
-                };
-                let mut items = this.tcx.item_children(krate);
-                let mut path_it = path.iter().skip(1).peekable();
-
-                while let Some(segment) = path_it.next() {
-                    for item in mem::replace(&mut items, Default::default()).iter() {
-                        if item.ident.name.as_str() == *segment {
-                            if path_it.peek().is_none() {
-                                return Some(ty::Instance::mono(this.tcx.tcx, item.res.def_id()));
-                            }
+/// Gets an instance for a path.
+pub fn resolve_did<'mir, 'tcx>(tcx: TyCtxt<'tcx>, path: &[&str]) -> InterpResult<'tcx, DefId> {
+    tcx
+        .crates()
+        .iter()
+        .find(|&&krate| tcx.original_crate_name(krate).as_str() == path[0])
+        .and_then(|krate| {
+            let krate = DefId {
+                krate: *krate,
+                index: CRATE_DEF_INDEX,
+            };
+            let mut items = tcx.item_children(krate);
+            let mut path_it = path.iter().skip(1).peekable();
 
-                            items = this.tcx.item_children(item.res.def_id());
-                            break;
+            while let Some(segment) = path_it.next() {
+                for item in mem::replace(&mut items, Default::default()).iter() {
+                    if item.ident.name.as_str() == *segment {
+                        if path_it.peek().is_none() {
+                            return Some(item.res.def_id())
+                            //eprintln!("Generics: {:?}", this.tcx.generics_of(item.res.def_id()));
+                            //return Some(ty::Instance::mono(this.tcx.tcx, item.res.def_id()).def_id());
                         }
+
+                        items = tcx.item_children(item.res.def_id());
+                        break;
                     }
                 }
                 None
@@ -44,6 +43,13 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 let path = path.iter().map(|&s| s.to_owned()).collect();
                 err_unsup!(PathNotFound(path)).into()
             })
+}
+
+
+pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
+
+    fn resolve_path(&self, path: &[&str]) -> InterpResult<'tcx, ty::Instance<'tcx>> {
+        Ok(ty::Instance::mono(self.eval_context_ref().tcx.tcx, resolve_did(self.eval_context_ref().tcx.tcx, path)?))
     }
 
     /// Write a 0 of the appropriate size to `dest`.

src/lib.rs

@@ -24,6 +24,7 @@ mod machine;
 mod eval;
 
 // Make all those symbols available in the same place as our own.
+
 pub use rustc_mir::interpret::*;
 // Resolve ambiguity.
 pub use rustc_mir::interpret::{self, AllocMap, PlaceTy};

src/machine.rs

@@ -8,6 +8,8 @@ use std::rc::Rc;
 use rand::rngs::StdRng;
 
 use rustc::hir::def_id::DefId;
+use rustc::ty::{self, Ty, TyCtxt, layout::{Size, LayoutOf, TyLayout}};
+use rustc::ty::{ExistentialPredicate, ExistentialTraitRef, RegionKind, List, ParamEnv, TyCtxt};
 use rustc::mir;
 use rustc::ty::{
     self,
@@ -25,6 +27,25 @@ pub const STACK_ADDR: u64 = 32 * PAGE_SIZE; // not really about the "stack", but
 pub const STACK_SIZE: u64 = 16 * PAGE_SIZE; // whatever
 pub const NUM_CPUS: u64 = 1;
 
+pub struct FrameData<'tcx> {
+    pub call_id: stacked_borrows::CallId,
+    pub catch_panic: Option<UnwindData<'tcx>>,
+    pub is_box_me_frame: bool
+}
+
+/// Hold all of the relevant data for a call to
+/// __rust_maybe_catch_panic
+///
+/// If a panic occurs, we update this data with
+/// the information from the panic site
+pub struct UnwindData<'tcx> {
+    pub data: Pointer<Tag>,
+    pub data_ptr: MPlaceTy<'tcx, Tag>,
+    pub vtable_ptr: MPlaceTy<'tcx, Tag>,
+    pub dest: PlaceTy<'tcx, Tag>,
+    pub ret: mir::BasicBlock,
+}
+
 /// Extra memory kinds
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum MiriMemoryKind {
@@ -38,6 +59,8 @@ pub enum MiriMemoryKind {
     Env,
     /// Statics.
     Static,
+    /// Temporary storage for implementing unwinding
+    UnwindHelper,
 }
 
 impl Into<MemoryKind<MiriMemoryKind>> for MiriMemoryKind {
@@ -78,6 +101,36 @@ impl MemoryExtra {
     }
 }
 
+pub struct CachedTypes<'tcx> {
+    /// The layout of the type '*mut &mut dyn core::panic::BoxMeUp'
+    pub box_me_up_layout: TyLayout<'tcx>,
+}
+
+impl<'tcx> CachedTypes<'tcx> {
+    pub fn new(tcx: TyCtxt<'tcx>) -> InterpResult<'tcx, CachedTypes<'tcx>> {
+        // We build up the layout of '*mut &mut dyn core::panic::BoxMeUp'
+        let box_me_up_did = helpers::resolve_did(tcx, &["core", "panic", "BoxMeUp"])?;
+        let traits = &[ExistentialPredicate::Trait(ExistentialTraitRef {
+            def_id: box_me_up_did,
+            substs: List::empty()
+        })];
+
+        let me_mut_dyn = tcx.mk_dynamic(
+            ty::Binder::dummy(tcx.intern_existential_predicates(traits)),
+            &RegionKind::ReErased
+        );
+
+        let me_mut_ref = tcx.mk_mut_ref(&RegionKind::ReErased, me_mut_dyn);
+        let me_mut_raw = tcx.mk_mut_ptr(me_mut_ref);
+        let box_me_up_layout = tcx.layout_of(ParamEnv::empty().and(me_mut_raw))
+            .map_err(|layout| InterpError::Layout(layout))?;
+
+        Ok(CachedTypes {
+            box_me_up_layout
+        })
+    }
+}
+
 /// The machine itself.
 pub struct Evaluator<'tcx> {
     /// Environment variables set by `setenv`.
@@ -102,10 +155,21 @@ pub struct Evaluator<'tcx> {
     pub(crate) communicate: bool,
 
     pub(crate) file_handler: FileHandler,
+
+    /// Extra information needed for unwinding
+    /// We create this even in abort mode, so
+    /// that we can perform some basic validation
+    /// during panics
+    pub(crate) cached_data: CachedTypes<'tcx>,
+
+    /// Whether or not we are currently unwinding from
+    /// a panic
+    pub(crate) unwinding: bool,
+    pub(crate) box_me_up_tmp_ptr: Option<MPlaceTy<'tcx, Tag>>
 }
 
 impl<'tcx> Evaluator<'tcx> {
-    pub(crate) fn new(communicate: bool) -> Self {
+    pub(crate) fn new(communicate: bool, cached_data: CachedTypes<'tcx>) -> Self {
         Evaluator {
             // `env_vars` could be initialized properly here if `Memory` were available before
             // calling this method.
@@ -117,6 +181,9 @@ impl<'tcx> Evaluator<'tcx> {
             tls: TlsData::default(),
             communicate,
             file_handler: Default::default(),
+            cached_data,
+            unwinding: false,
+            box_me_up_tmp_ptr: None
         }
     }
 }
@@ -144,7 +211,7 @@ impl<'mir, 'tcx> MiriEvalContextExt<'mir, 'tcx> for MiriEvalContext<'mir, 'tcx>
 impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
     type MemoryKinds = MiriMemoryKind;
 
-    type FrameExtra = stacked_borrows::CallId;
+    type FrameExtra = FrameData<'tcx>;
     type MemoryExtra = MemoryExtra;
     type AllocExtra = AllocExtra;
     type PointerTag = Tag;
@@ -174,8 +241,9 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
         args: &[OpTy<'tcx, Tag>],
         dest: Option<PlaceTy<'tcx, Tag>>,
         ret: Option<mir::BasicBlock>,
+        unwind: Option<mir::BasicBlock>,
     ) -> InterpResult<'tcx, Option<&'mir mir::Body<'tcx>>> {
-        ecx.find_fn(instance, args, dest, ret)
+        ecx.find_fn(instance, args, dest, ret, unwind)
     }
 
     #[inline(always)]
@@ -348,21 +416,66 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'tcx> {
     #[inline(always)]
     fn stack_push(
         ecx: &mut InterpCx<'mir, 'tcx, Self>,
-    ) -> InterpResult<'tcx, stacked_borrows::CallId> {
-        Ok(ecx.memory().extra.stacked_borrows.borrow_mut().new_call())
+    ) -> InterpResult<'tcx, FrameData<'tcx>> {
+        Ok(FrameData {
+            call_id: ecx.memory().extra.stacked_borrows.borrow_mut().new_call(),
+            catch_panic: None,
+            is_box_me_frame: false
+        })
     }
 
     #[inline(always)]
     fn stack_pop(
         ecx: &mut InterpCx<'mir, 'tcx, Self>,
-        extra: stacked_borrows::CallId,
-    ) -> InterpResult<'tcx> {
-        Ok(ecx
-            .memory()
-            .extra
-            .stacked_borrows
-            .borrow_mut()
-            .end_call(extra))
+        extra: FrameData<'tcx>,
+    ) -> InterpResult<'tcx, StackPopInfo> {
+        if extra.is_box_me_frame {
+            trace!("unwinding: found box_me_frame");
+            ecx.machine.unwinding = true;
+        }
+        if ecx.machine.unwinding {
+            trace!("Popping during unwind!");
+            if let Some(unwind_data) = ecx.frame_mut().extra.catch_panic.take() {
+                // We've just popped the frame that was immediately above
+                // our target frame on the stack.
+                //
+                trace!("unwinding: found target frame: {:?}", ecx.frame().span);
+
+                // 'box_me_up' has finished. 'temp_ptr' now holds
+                // a '*mut (dyn Any + Send)'
+                // We want to split this into its consituient parts -
+                // the data and vtable pointers - and store them back
+                // into the panic handler frame
+                let tmp_ptr = ecx.machine.box_me_up_tmp_ptr.take().unwrap();
+                let real_ret = ecx.read_immediate(tmp_ptr.into())?;
+                let payload_data_ptr = real_ret.to_scalar_ptr()?;
+                let payload_vtable_ptr = real_ret.to_meta()?.expect("Expected fat pointer");
+
+
+                let data_ptr = unwind_data.data_ptr.clone();
+                let vtable_ptr = unwind_data.vtable_ptr.clone();
+                let dest = unwind_data.dest.clone();
+                drop(unwind_data);
+
+
+                // Here, we write directly into the frame of the function
+                // that called '__rust_maybe_catch_panic'.
+                // (NOT the function that called '__rust_start_panic')
+
+                ecx.write_scalar(payload_data_ptr, data_ptr.into())?;
+                ecx.write_scalar(payload_vtable_ptr, vtable_ptr.into())?;
+
+                // We 'return' the value 1 from __rust_maybe_catch_panic,
+                // since there was a panic
+                ecx.write_scalar(Scalar::from_int(1, dest.layout.size), dest)?;
+                ecx.machine.unwinding = false;
+
+                ecx.memory_mut().deallocate(tmp_ptr.to_ptr()?, None, MiriMemoryKind::UnwindHelper.into())?;
+            }
+        }
+        ecx.memory().extra.stacked_borrows.borrow_mut().end_call(extra.call_id);
+        Ok(StackPopInfo { unwinding: ecx.machine.unwinding })
+>>>>>>> Support unwinding after a panic
     }
 
     #[inline(always)]
@@ -428,7 +541,7 @@ impl MayLeak for MiriMemoryKind {
     fn may_leak(self) -> bool {
         use self::MiriMemoryKind::*;
         match self {
-            Rust | C | WinHeap => false,
+            Rust | C | WinHeap | UnwindHelper => false,
             Env | Static => true,
         }
     }