1 //! Panic runtime for Miri.
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.
16 use rustc_ast::Mutability;
17 use rustc_middle::{mir, ty};
18 use rustc_span::Symbol;
19 use rustc_target::spec::abi::Abi;
20 use rustc_target::spec::PanicStrategy;
23 use helpers::check_arg_count;
25 /// Holds all of the relevant data for when unwinding hits a `try` frame.
27 pub struct CatchUnwindData<'tcx> {
28 /// The `catch_fn` callback to call in case of a panic.
29 catch_fn: Pointer<Option<Provenance>>,
30 /// The `data` argument for that callback.
31 data: Scalar<Provenance>,
32 /// The return place from the original call to `try`.
33 dest: PlaceTy<'tcx, Provenance>,
34 /// The return block from the original call to `try`.
38 impl VisitTags for CatchUnwindData<'_> {
39 fn visit_tags(&self, visit: &mut dyn FnMut(BorTag)) {
40 let CatchUnwindData { catch_fn, data, dest, ret: _ } = self;
41 catch_fn.visit_tags(visit);
42 data.visit_tags(visit);
43 dest.visit_tags(visit);
47 impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriInterpCx<'mir, 'tcx> {}
48 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriInterpCxExt<'mir, 'tcx> {
49 /// Handles the special `miri_start_panic` intrinsic, which is called
50 /// by libpanic_unwind to delegate the actual unwinding process to Miri.
51 fn handle_miri_start_panic(
55 args: &[OpTy<'tcx, Provenance>],
56 unwind: StackPopUnwind,
57 ) -> InterpResult<'tcx> {
58 let this = self.eval_context_mut();
60 trace!("miri_start_panic: {:?}", this.frame().instance);
62 // Get the raw pointer stored in arg[0] (the panic payload).
63 let [payload] = this.check_shim(abi, Abi::Rust, link_name, args)?;
64 let payload = this.read_scalar(payload)?;
65 let thread = this.active_thread_mut();
66 assert!(thread.panic_payload.is_none(), "the panic runtime should avoid double-panics");
67 thread.panic_payload = Some(payload);
69 // Jump to the unwind block to begin unwinding.
70 this.unwind_to_block(unwind)?;
74 /// Handles the `try` intrinsic, the underlying implementation of `std::panicking::try`.
77 args: &[OpTy<'tcx, Provenance>],
78 dest: &PlaceTy<'tcx, Provenance>,
80 ) -> InterpResult<'tcx> {
81 let this = self.eval_context_mut();
84 // fn r#try(try_fn: fn(*mut u8), data: *mut u8, catch_fn: fn(*mut u8, *mut u8)) -> i32
85 // Calls `try_fn` with `data` as argument. If that executes normally, returns 0.
86 // If that unwinds, calls `catch_fn` with the first argument being `data` and
87 // then second argument being a target-dependent `payload` (i.e. it is up to us to define
88 // what that is), and returns 1.
89 // The `payload` is passed (by libstd) to `__rust_panic_cleanup`, which is then expected to
90 // return a `Box<dyn Any + Send + 'static>`.
91 // In Miri, `miri_start_panic` is passed exactly that type, so we make the `payload` simply
92 // a pointer to `Box<dyn Any + Send + 'static>`.
94 // Get all the arguments.
95 let [try_fn, data, catch_fn] = check_arg_count(args)?;
96 let try_fn = this.read_pointer(try_fn)?;
97 let data = this.read_scalar(data)?;
98 let catch_fn = this.read_pointer(catch_fn)?;
100 // Now we make a function call, and pass `data` as first and only argument.
101 let f_instance = this.get_ptr_fn(try_fn)?.as_instance()?;
102 trace!("try_fn: {:?}", f_instance);
108 // Directly return to caller.
109 StackPopCleanup::Goto { ret: Some(ret), unwind: StackPopUnwind::Skip },
112 // We ourselves will return `0`, eventually (will be overwritten if we catch a panic).
113 this.write_null(dest)?;
115 // In unwind mode, we tag this frame with the extra data needed to catch unwinding.
116 // This lets `handle_stack_pop` (below) know that we should stop unwinding
117 // when we pop this frame.
118 if this.tcx.sess.panic_strategy() == PanicStrategy::Unwind {
119 this.frame_mut().extra.catch_unwind =
120 Some(CatchUnwindData { catch_fn, data, dest: dest.clone(), ret });
126 fn handle_stack_pop_unwind(
128 mut extra: FrameExtra<'tcx>,
130 ) -> InterpResult<'tcx, StackPopJump> {
131 let this = self.eval_context_mut();
132 trace!("handle_stack_pop_unwind(extra = {:?}, unwinding = {})", extra, unwinding);
134 // We only care about `catch_panic` if we're unwinding - if we're doing a normal
135 // return, then we don't need to do anything special.
136 if let (true, Some(catch_unwind)) = (unwinding, extra.catch_unwind.take()) {
137 // We've just popped a frame that was pushed by `try`,
138 // and we are unwinding, so we should catch that.
140 "unwinding: found catch_panic frame during unwinding: {:?}",
141 this.frame().instance
144 // We set the return value of `try` to 1, since there was a panic.
145 this.write_scalar(Scalar::from_i32(1), &catch_unwind.dest)?;
147 // The Thread's `panic_payload` holds what was passed to `miri_start_panic`.
148 // This is exactly the second argument we need to pass to `catch_fn`.
149 let payload = this.active_thread_mut().panic_payload.take().unwrap();
151 // Push the `catch_fn` stackframe.
152 let f_instance = this.get_ptr_fn(catch_unwind.catch_fn)?.as_instance()?;
153 trace!("catch_fn: {:?}", f_instance);
157 &[catch_unwind.data.into(), payload.into()],
159 // Directly return to caller of `try`.
160 StackPopCleanup::Goto { ret: Some(catch_unwind.ret), unwind: StackPopUnwind::Skip },
163 // We pushed a new stack frame, the engine should not do any jumping now!
164 Ok(StackPopJump::NoJump)
166 Ok(StackPopJump::Normal)
170 /// Start a panic in the interpreter with the given message as payload.
171 fn start_panic(&mut self, msg: &str, unwind: StackPopUnwind) -> InterpResult<'tcx> {
172 let this = self.eval_context_mut();
174 // First arg: message.
175 let msg = this.allocate_str(msg, MiriMemoryKind::Machine.into(), Mutability::Not);
177 // Call the lang item.
178 let panic = this.tcx.lang_items().panic_fn().unwrap();
179 let panic = ty::Instance::mono(this.tcx.tcx, panic);
185 StackPopCleanup::Goto { ret: None, unwind },
191 msg: &mir::AssertMessage<'tcx>,
192 unwind: Option<mir::BasicBlock>,
193 ) -> InterpResult<'tcx> {
194 use rustc_middle::mir::AssertKind::*;
195 let this = self.eval_context_mut();
198 BoundsCheck { index, len } => {
199 // Forward to `panic_bounds_check` lang item.
202 let index = this.read_scalar(&this.eval_operand(index, None)?)?;
204 let len = this.read_scalar(&this.eval_operand(len, None)?)?;
206 // Call the lang item.
207 let panic_bounds_check = this.tcx.lang_items().panic_bounds_check_fn().unwrap();
208 let panic_bounds_check = ty::Instance::mono(this.tcx.tcx, panic_bounds_check);
212 &[index.into(), len.into()],
214 StackPopCleanup::Goto {
216 unwind: match unwind {
217 Some(cleanup) => StackPopUnwind::Cleanup(cleanup),
218 None => StackPopUnwind::Skip,
224 // Forward everything else to `panic` lang item.
228 Some(cleanup) => StackPopUnwind::Cleanup(cleanup),
229 None => StackPopUnwind::Skip,