miri/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_unwind` intrinsic instead of the
7//!   target-native panic runtime. (This lives in the rustc repo.)
8//! - An implementation of `miri_start_unwind` 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
14use rustc_abi::ExternAbi;
15use rustc_middle::{mir, ty};
16use rustc_target::spec::PanicStrategy;
17
18use self::helpers::check_intrinsic_arg_count;
19use crate::*;
20
21/// Holds all of the relevant data for when unwinding hits a `try` frame.
22#[derive(Debug)]
23pub struct CatchUnwindData<'tcx> {
24    /// The `catch_fn` callback to call in case of a panic.
25    catch_fn: Pointer,
26    /// The `data` argument for that callback.
27    data: ImmTy<'tcx>,
28    /// The return place from the original call to `try`.
29    dest: MPlaceTy<'tcx>,
30    /// The return block from the original call to `try`.
31    ret: Option<mir::BasicBlock>,
32}
33
34impl VisitProvenance for CatchUnwindData<'_> {
35    fn visit_provenance(&self, visit: &mut VisitWith<'_>) {
36        let CatchUnwindData { catch_fn, data, dest, ret: _ } = self;
37        catch_fn.visit_provenance(visit);
38        data.visit_provenance(visit);
39        dest.visit_provenance(visit);
40    }
41}
42
43impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
44pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
45    /// Handles the special `miri_start_unwind` intrinsic, which is called
46    /// by libpanic_unwind to delegate the actual unwinding process to Miri.
47    fn handle_miri_start_unwind(&mut self, payload: &OpTy<'tcx>) -> InterpResult<'tcx> {
48        let this = self.eval_context_mut();
49
50        trace!("miri_start_unwind: {:?}", this.frame().instance());
51
52        let payload = this.read_immediate(payload)?;
53        let thread = this.active_thread_mut();
54        thread.panic_payloads.push(payload);
55
56        interp_ok(())
57    }
58
59    /// Handles the `catch_unwind` intrinsic.
60    fn handle_catch_unwind(
61        &mut self,
62        args: &[OpTy<'tcx>],
63        dest: &MPlaceTy<'tcx>,
64        ret: Option<mir::BasicBlock>,
65    ) -> InterpResult<'tcx> {
66        let this = self.eval_context_mut();
67
68        // Signature:
69        //   fn catch_unwind(try_fn: fn(*mut u8), data: *mut u8, catch_fn: fn(*mut u8, *mut u8)) -> i32
70        // Calls `try_fn` with `data` as argument. If that executes normally, returns 0.
71        // If that unwinds, calls `catch_fn` with the first argument being `data` and
72        // then second argument being a target-dependent `payload` (i.e. it is up to us to define
73        // what that is), and returns 1.
74        // The `payload` is passed (by libstd) to `__rust_panic_cleanup`, which is then expected to
75        // return a `Box<dyn Any + Send + 'static>`.
76        // In Miri, `miri_start_unwind` is passed exactly that type, so we make the `payload` simply
77        // a pointer to `Box<dyn Any + Send + 'static>`.
78
79        // Get all the arguments.
80        let [try_fn, data, catch_fn] = check_intrinsic_arg_count(args)?;
81        let try_fn = this.read_pointer(try_fn)?;
82        let data = this.read_immediate(data)?;
83        let catch_fn = this.read_pointer(catch_fn)?;
84
85        // Now we make a function call, and pass `data` as first and only argument.
86        let f_instance = this.get_ptr_fn(try_fn)?.as_instance()?;
87        trace!("try_fn: {:?}", f_instance);
88        #[allow(clippy::cloned_ref_to_slice_refs)] // the code is clearer as-is
89        this.call_function(
90            f_instance,
91            ExternAbi::Rust,
92            &[data.clone()],
93            None,
94            // Directly return to caller.
95            StackPopCleanup::Goto { ret, unwind: mir::UnwindAction::Continue },
96        )?;
97
98        // We ourselves will return `0`, eventually (will be overwritten if we catch a panic).
99        this.write_null(dest)?;
100
101        // In unwind mode, we tag this frame with the extra data needed to catch unwinding.
102        // This lets `handle_stack_pop` (below) know that we should stop unwinding
103        // when we pop this frame.
104        if this.tcx.sess.panic_strategy() == PanicStrategy::Unwind {
105            this.frame_mut().extra.catch_unwind =
106                Some(CatchUnwindData { catch_fn, data, dest: dest.clone(), ret });
107        }
108
109        interp_ok(())
110    }
111
112    fn handle_stack_pop_unwind(
113        &mut self,
114        mut extra: FrameExtra<'tcx>,
115        unwinding: bool,
116    ) -> InterpResult<'tcx, ReturnAction> {
117        let this = self.eval_context_mut();
118        trace!("handle_stack_pop_unwind(extra = {:?}, unwinding = {})", extra, unwinding);
119
120        // We only care about `catch_panic` if we're unwinding - if we're doing a normal
121        // return, then we don't need to do anything special.
122        if let (true, Some(catch_unwind)) = (unwinding, extra.catch_unwind.take()) {
123            // We've just popped a frame that was pushed by `catch_unwind`,
124            // and we are unwinding, so we should catch that.
125            trace!(
126                "unwinding: found catch_panic frame during unwinding: {:?}",
127                this.frame().instance()
128            );
129
130            // We set the return value of `catch_unwind` to 1, since there was a panic.
131            this.write_scalar(Scalar::from_i32(1), &catch_unwind.dest)?;
132
133            // The Thread's `panic_payload` holds what was passed to `miri_start_unwind`.
134            // This is exactly the second argument we need to pass to `catch_fn`.
135            let payload = this.active_thread_mut().panic_payloads.pop().unwrap();
136
137            // Push the `catch_fn` stackframe.
138            let f_instance = this.get_ptr_fn(catch_unwind.catch_fn)?.as_instance()?;
139            trace!("catch_fn: {:?}", f_instance);
140            this.call_function(
141                f_instance,
142                ExternAbi::Rust,
143                &[catch_unwind.data, payload],
144                None,
145                // Directly return to caller of `catch_unwind`.
146                StackPopCleanup::Goto {
147                    ret: catch_unwind.ret,
148                    // `catch_fn` must not unwind.
149                    unwind: mir::UnwindAction::Unreachable,
150                },
151            )?;
152
153            // We pushed a new stack frame, the engine should not do any jumping now!
154            interp_ok(ReturnAction::NoJump)
155        } else {
156            interp_ok(ReturnAction::Normal)
157        }
158    }
159
160    /// Start a panic in the interpreter with the given message as payload.
161    fn start_panic(&mut self, msg: &str, unwind: mir::UnwindAction) -> InterpResult<'tcx> {
162        let this = self.eval_context_mut();
163
164        // First arg: message.
165        let msg = this.allocate_str_dedup(msg)?;
166
167        // Call the lang item.
168        let panic = this.tcx.lang_items().panic_fn().unwrap();
169        let panic = ty::Instance::mono(this.tcx.tcx, panic);
170        this.call_function(
171            panic,
172            ExternAbi::Rust,
173            &[this.mplace_to_ref(&msg)?],
174            None,
175            StackPopCleanup::Goto { ret: None, unwind },
176        )
177    }
178
179    /// Start a non-unwinding panic in the interpreter with the given message as payload.
180    fn start_panic_nounwind(&mut self, msg: &str) -> InterpResult<'tcx> {
181        let this = self.eval_context_mut();
182
183        // First arg: message.
184        let msg = this.allocate_str_dedup(msg)?;
185
186        // Call the lang item.
187        let panic = this.tcx.lang_items().panic_nounwind().unwrap();
188        let panic = ty::Instance::mono(this.tcx.tcx, panic);
189        this.call_function(
190            panic,
191            ExternAbi::Rust,
192            &[this.mplace_to_ref(&msg)?],
193            None,
194            StackPopCleanup::Goto { ret: None, unwind: mir::UnwindAction::Unreachable },
195        )
196    }
197
198    fn assert_panic(
199        &mut self,
200        msg: &mir::AssertMessage<'tcx>,
201        unwind: mir::UnwindAction,
202    ) -> InterpResult<'tcx> {
203        use rustc_middle::mir::AssertKind::*;
204        let this = self.eval_context_mut();
205
206        match msg {
207            BoundsCheck { index, len } => {
208                // Forward to `panic_bounds_check` lang item.
209
210                // First arg: index.
211                let index = this.read_immediate(&this.eval_operand(index, None)?)?;
212                // Second arg: len.
213                let len = this.read_immediate(&this.eval_operand(len, None)?)?;
214
215                // Call the lang item.
216                let panic_bounds_check = this.tcx.lang_items().panic_bounds_check_fn().unwrap();
217                let panic_bounds_check = ty::Instance::mono(this.tcx.tcx, panic_bounds_check);
218                this.call_function(
219                    panic_bounds_check,
220                    ExternAbi::Rust,
221                    &[index, len],
222                    None,
223                    StackPopCleanup::Goto { ret: None, unwind },
224                )?;
225            }
226            MisalignedPointerDereference { required, found } => {
227                // Forward to `panic_misaligned_pointer_dereference` lang item.
228
229                // First arg: required.
230                let required = this.read_immediate(&this.eval_operand(required, None)?)?;
231                // Second arg: found.
232                let found = this.read_immediate(&this.eval_operand(found, None)?)?;
233
234                // Call the lang item.
235                let panic_misaligned_pointer_dereference =
236                    this.tcx.lang_items().panic_misaligned_pointer_dereference_fn().unwrap();
237                let panic_misaligned_pointer_dereference =
238                    ty::Instance::mono(this.tcx.tcx, panic_misaligned_pointer_dereference);
239                this.call_function(
240                    panic_misaligned_pointer_dereference,
241                    ExternAbi::Rust,
242                    &[required, found],
243                    None,
244                    StackPopCleanup::Goto { ret: None, unwind },
245                )?;
246            }
247
248            _ => {
249                // Call the lang item associated with this message.
250                let fn_item = this.tcx.require_lang_item(msg.panic_function(), None);
251                let instance = ty::Instance::mono(this.tcx.tcx, fn_item);
252                this.call_function(
253                    instance,
254                    ExternAbi::Rust,
255                    &[],
256                    None,
257                    StackPopCleanup::Goto { ret: None, unwind },
258                )?;
259            }
260        }
261        interp_ok(())
262    }
263}