src/shims/panic.rs

   1 //! Panic runtime for Miri.
   2 //!
   3 //! The core pieces of the runtime are:
   4 //! - An implementation of `__rust_maybe_catch_panic` that pushes the invoked stack frame with
   5 //!   some extra metadata derived from the panic-catching arguments of `__rust_maybe_catch_panic`.
   6 //! - A hack in `libpanic_unwind` that calls the `miri_start_panic` intrinsic instead of the
   7 //!   target-native panic runtime. (This lives in the rustc repo.)
   8 //! - An implementation of `miri_start_panic` that stores its argument (the panic payload), and then
   9 //!   immediately returns, but on the *unwind* edge (not the normal return edge), thus initiating unwinding.
  10 //! - A hook executed each time a frame is popped, such that if the frame pushed by `__rust_maybe_catch_panic`
  11 //!   gets popped *during unwinding*, we take the panic payload and store it according to the extra
  12 //!   metadata we remembered when pushing said frame.
  13
  14 use rustc::mir;
  15 use crate::*;
  16 use super::machine::FrameData;
  17 use rustc_target::spec::PanicStrategy;
  18 use crate::rustc_target::abi::LayoutOf;
  19
  20 /// Holds all of the relevant data for a call to
  21 /// `__rust_maybe_catch_panic`.
  22 ///
  23 /// If a panic occurs, we update this data with
  24 /// the information from the panic site.
  25 #[derive(Debug)]
  26 pub struct CatchUnwindData<'tcx> {
  27     /// The dereferenced `data_ptr` argument passed to `__rust_maybe_catch_panic`.
  28     pub data_place: MPlaceTy<'tcx, Tag>,
  29     /// The dereferenced `vtable_ptr` argument passed to `__rust_maybe_catch_panic`.
  30     pub vtable_place: MPlaceTy<'tcx, Tag>,
  31     /// The `dest` from the original call to `__rust_maybe_catch_panic`.
  32     pub dest: PlaceTy<'tcx, Tag>,
  33 }
  34
  35 impl<'mir, 'tcx> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
  36 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
  37
  38     /// Handles the special "miri_start_panic" intrinsic, which is called
  39     /// by libpanic_unwind to delegate the actual unwinding process to Miri.
  40     #[inline(always)]
  41     fn handle_miri_start_panic(
  42         &mut self,
  43         args: &[OpTy<'tcx, Tag>],
  44         unwind: Option<mir::BasicBlock>
  45     ) -> InterpResult<'tcx> {
  46         let this = self.eval_context_mut();
  47
  48         trace!("miri_start_panic: {:?}", this.frame().span);
  49
  50         if this.tcx.tcx.sess.panic_strategy() == PanicStrategy::Abort  {
  51             // FIXME: Add a better way of indicating 'abnormal' termination,
  52             // since this is not really an 'unsupported' behavior
  53             throw_unsup_format!("the evaluated program panicked");
  54         }
  55
  56         // Get the raw pointer stored in arg[0] (the panic payload).
  57         let scalar = this.read_immediate(args[0])?;
  58         assert!(this.machine.panic_payload.is_none(), "the panic runtime should avoid double-panics");
  59         this.machine.panic_payload = Some(scalar);
  60
  61         // Jump to the unwind block to begin unwinding.
  62         // We don't use `goto_block` as that is just meant for normal returns.
  63         let next_frame = this.frame_mut();
  64         next_frame.block = unwind;
  65         next_frame.stmt = 0;
  66         return Ok(())
  67     }
  68
  69     #[inline(always)]
  70     fn handle_catch_panic(
  71         &mut self,
  72         args: &[OpTy<'tcx, Tag>],
  73         dest: PlaceTy<'tcx, Tag>,
  74         ret: mir::BasicBlock,
  75     ) -> InterpResult<'tcx> {
  76         let this = self.eval_context_mut();
  77         let tcx = &{this.tcx.tcx};
  78
  79         // fn __rust_maybe_catch_panic(
  80         //     f: fn(*mut u8),
  81         //     data: *mut u8,
  82         //     data_ptr: *mut usize,
  83         //     vtable_ptr: *mut usize,
  84         // ) -> u32
  85
  86         // Get all the arguments.
  87         let f = this.read_scalar(args[0])?.not_undef()?;
  88         let f_arg = this.read_scalar(args[1])?.not_undef()?;
  89         let data_place = this.deref_operand(args[2])?;
  90         let vtable_place = this.deref_operand(args[3])?;
  91
  92         // Now we make a function call, and pass `f_arg` as first and only argument.
  93         let f_instance = this.memory.get_fn(f)?.as_instance()?;
  94         trace!("__rust_maybe_catch_panic: {:?}", f_instance);
  95         // TODO: consider making this reusable? `InterpCx::step` does something similar
  96         // for the TLS destructors, and of course `eval_main`.
  97         let mir = this.load_mir(f_instance.def, None)?;
  98         let ret_place =
  99             MPlaceTy::dangling(this.layout_of(tcx.mk_unit())?, this).into();
 100         this.push_stack_frame(
 101             f_instance,
 102             mir.span,
 103             mir,
 104             Some(ret_place),
 105             // Directly return to caller.
 106             StackPopCleanup::Goto { ret: Some(ret), unwind: None },
 107         )?;
 108
 109         let mut args = this.frame().body.args_iter();
 110         // First argument.
 111         let arg_local = args
 112             .next()
 113             .expect("Argument to __rust_maybe_catch_panic does not take enough arguments.");
 114         let arg_dest = this.local_place(arg_local)?;
 115         this.write_scalar(f_arg, arg_dest)?;
 116         // No more arguments.
 117         args.next().expect_none("__rust_maybe_catch_panic argument has more arguments than expected");
 118
 119         // We ourselves will return `0`, eventually (will be overwritten if we catch a panic).
 120         this.write_null(dest)?;
 121
 122         // In unwind mode, we tag this frame with some extra data.
 123         // This lets `handle_stack_pop` (below) know that we should stop unwinding
 124         // when we pop this frame.
 125         if this.tcx.tcx.sess.panic_strategy() == PanicStrategy::Unwind {
 126             this.frame_mut().extra.catch_panic = Some(CatchUnwindData {
 127                 data_place,
 128                 vtable_place,
 129                 dest,
 130             })
 131         }
 132
 133         return Ok(());
 134     }
 135
 136     #[inline(always)]
 137     fn handle_stack_pop(
 138         &mut self,
 139         mut extra: FrameData<'tcx>,
 140         unwinding: bool
 141     ) -> InterpResult<'tcx, StackPopInfo> {
 142         let this = self.eval_context_mut();
 143
 144         trace!("handle_stack_pop(extra = {:?}, unwinding = {})", extra, unwinding);
 145
 146         // We only care about `catch_panic` if we're unwinding - if we're doing a normal
 147         // return, then we don't need to do anything special.
 148         let res = if let (true, Some(unwind_data)) = (unwinding, extra.catch_panic.take()) {
 149             // We've just popped a frame that was pushed by `__rust_maybe_catch_panic`,
 150             // and we are unwinding, so we should catch that.
 151             trace!("unwinding: found catch_panic frame during unwinding: {:?}", this.frame().span);
 152
 153             // `panic_payload` now holds a `*mut (dyn Any + Send)`,
 154             // provided by the `miri_start_panic` intrinsic.
 155             // We want to split this into its consituient parts -
 156             // the data and vtable pointers - and store them according to
 157             // `unwind_data`, i.e., we store them where `__rust_maybe_catch_panic`
 158             // was told to put them.
 159             let payload = this.machine.panic_payload.take().unwrap();
 160             let payload = this.ref_to_mplace(payload)?;
 161             let payload_data_place = payload.ptr;
 162             let payload_vtable_place = payload.meta.expect("Expected fat pointer");
 163
 164             this.write_scalar(payload_data_place, unwind_data.data_place.into())?;
 165             this.write_scalar(payload_vtable_place, unwind_data.vtable_place.into())?;
 166
 167             // We set the return value of `__rust_maybe_catch_panic` to 1,
 168             // since there was a panic.
 169             let dest = unwind_data.dest;
 170             this.write_scalar(Scalar::from_int(1, dest.layout.size), dest)?;
 171
 172             StackPopInfo::StopUnwinding
 173         } else {
 174             StackPopInfo::Normal
 175         };
 176         this.memory.extra.stacked_borrows.borrow_mut().end_call(extra.call_id);
 177         Ok(res)
 178     }
 179 }