1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use alloc::boxed::Box;
use core::any::Any;
use core::mem::MaybeUninit;

use crate::abi::*;
#[cfg(feature = "panic-handler")]
pub use crate::panic_handler::*;
use crate::panicking::Exception;

static CANARY: u8 = 0;

#[repr(transparent)]
struct RustPanic(Box<dyn Any + Send>, DropGuard);

struct DropGuard;

impl Drop for DropGuard {
    fn drop(&mut self) {
        #[cfg(feature = "panic-handler")]
        {
            drop_panic();
        }
        crate::util::abort();
    }
}

#[repr(C)]
struct ExceptionWithPayload {
    exception: MaybeUninit<UnwindException>,
    // See rust/library/panic_unwind/src/gcc.rs for the canary values
    canary: *const u8,
    payload: RustPanic,
}

unsafe impl Exception for RustPanic {
    const CLASS: [u8; 8] = *b"MOZ\0RUST";

    fn wrap(this: Self) -> *mut UnwindException {
        Box::into_raw(Box::new(ExceptionWithPayload {
            exception: MaybeUninit::uninit(),
            canary: &CANARY,
            payload: this,
        })) as *mut UnwindException
    }

    unsafe fn unwrap(ex: *mut UnwindException) -> Self {
        let ex = ex as *mut ExceptionWithPayload;
        let canary = unsafe { core::ptr::addr_of!((*ex).canary).read() };
        if !core::ptr::eq(canary, &CANARY) {
            // This is a Rust exception but not generated by us.
            #[cfg(feature = "panic-handler")]
            {
                foreign_exception();
            }
            crate::util::abort();
        }
        let ex = unsafe { Box::from_raw(ex) };
        ex.payload
    }
}

pub fn begin_panic(payload: Box<dyn Any + Send>) -> UnwindReasonCode {
    crate::panicking::begin_panic(RustPanic(payload, DropGuard))
}

pub fn catch_unwind<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {
    #[cold]
    fn process_panic(p: Option<RustPanic>) -> Box<dyn Any + Send> {
        match p {
            None => {
                #[cfg(feature = "panic-handler")]
                {
                    foreign_exception();
                }
                crate::util::abort();
            }
            Some(e) => {
                #[cfg(feature = "panic-handler")]
                {
                    panic_caught();
                }
                core::mem::forget(e.1);
                e.0
            }
        }
    }
    crate::panicking::catch_unwind(f).map_err(process_panic)
}