library/panic_unwind/src/emcc.rs

   1 //! Unwinding for *emscripten* target.
   2 //!
   3 //! Whereas Rust's usual unwinding implementation for Unix platforms
   4 //! calls into the libunwind APIs directly, on Emscripten we instead
   5 //! call into the C++ unwinding APIs. This is just an expedience since
   6 //! Emscripten's runtime always implements those APIs and does not
   7 //! implement libunwind.
   8
   9 use alloc::boxed::Box;
  10 use core::any::Any;
  11 use core::intrinsics;
  12 use core::mem;
  13 use core::ptr;
  14 use core::sync::atomic::{AtomicBool, Ordering};
  15 use libc::{self, c_int};
  16 use unwind as uw;
  17
  18 // This matches the layout of std::type_info in C++
  19 #[repr(C)]
  20 struct TypeInfo {
  21     vtable: *const usize,
  22     name: *const u8,
  23 }
  24 unsafe impl Sync for TypeInfo {}
  25
  26 extern "C" {
  27     // The leading `\x01` byte here is actually a magical signal to LLVM to
  28     // *not* apply any other mangling like prefixing with a `_` character.
  29     //
  30     // This symbol is the vtable used by C++'s `std::type_info`. Objects of type
  31     // `std::type_info`, type descriptors, have a pointer to this table. Type
  32     // descriptors are referenced by the C++ EH structures defined above and
  33     // that we construct below.
  34     //
  35     // Note that the real size is larger than 3 usize, but we only need our
  36     // vtable to point to the third element.
  37     #[link_name = "\x01_ZTVN10__cxxabiv117__class_type_infoE"]
  38     static CLASS_TYPE_INFO_VTABLE: [usize; 3];
  39 }
  40
  41 // std::type_info for a rust_panic class
  42 #[lang = "eh_catch_typeinfo"]
  43 static EXCEPTION_TYPE_INFO: TypeInfo = TypeInfo {
  44     // Normally we would use .as_ptr().add(2) but this doesn't work in a const context.
  45     vtable: unsafe { &CLASS_TYPE_INFO_VTABLE[2] },
  46     // This intentionally doesn't use the normal name mangling scheme because
  47     // we don't want C++ to be able to produce or catch Rust panics.
  48     name: b"rust_panic\0".as_ptr(),
  49 };
  50
  51 struct Exception {
  52     // This is necessary because C++ code can capture our exception with
  53     // std::exception_ptr and rethrow it multiple times, possibly even in
  54     // another thread.
  55     caught: AtomicBool,
  56
  57     // This needs to be an Option because the object's lifetime follows C++
  58     // semantics: when catch_unwind moves the Box out of the exception it must
  59     // still leave the exception object in a valid state because its destructor
  60     // is still going to be called by __cxa_end_catch.
  61     data: Option<Box<dyn Any + Send>>,
  62 }
  63
  64 pub unsafe fn cleanup(ptr: *mut u8) -> Box<dyn Any + Send> {
  65     // intrinsics::try actually gives us a pointer to this structure.
  66     #[repr(C)]
  67     struct CatchData {
  68         ptr: *mut u8,
  69         is_rust_panic: bool,
  70     }
  71     let catch_data = &*(ptr as *mut CatchData);
  72
  73     let adjusted_ptr = __cxa_begin_catch(catch_data.ptr as *mut libc::c_void) as *mut Exception;
  74     let out = if catch_data.is_rust_panic {
  75         let was_caught = (*adjusted_ptr).caught.swap(true, Ordering::SeqCst);
  76         if was_caught {
  77             // Since cleanup() isn't allowed to panic, we just abort instead.
  78             intrinsics::abort();
  79         }
  80         (*adjusted_ptr).data.take().unwrap()
  81     } else {
  82         super::__rust_foreign_exception();
  83     };
  84     __cxa_end_catch();
  85     out
  86 }
  87
  88 pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
  89     let sz = mem::size_of_val(&data);
  90     let exception = __cxa_allocate_exception(sz) as *mut Exception;
  91     if exception.is_null() {
  92         return uw::_URC_FATAL_PHASE1_ERROR as u32;
  93     }
  94     ptr::write(exception, Exception { caught: AtomicBool::new(false), data: Some(data) });
  95     __cxa_throw(exception as *mut _, &EXCEPTION_TYPE_INFO, exception_cleanup);
  96 }
  97
  98 extern "C" fn exception_cleanup(ptr: *mut libc::c_void) -> *mut libc::c_void {
  99     unsafe {
 100         if let Some(b) = (ptr as *mut Exception).read().data {
 101             drop(b);
 102             super::__rust_drop_panic();
 103         }
 104         ptr
 105     }
 106 }
 107
 108 #[lang = "eh_personality"]
 109 unsafe extern "C" fn rust_eh_personality(
 110     version: c_int,
 111     actions: uw::_Unwind_Action,
 112     exception_class: uw::_Unwind_Exception_Class,
 113     exception_object: *mut uw::_Unwind_Exception,
 114     context: *mut uw::_Unwind_Context,
 115 ) -> uw::_Unwind_Reason_Code {
 116     __gxx_personality_v0(version, actions, exception_class, exception_object, context)
 117 }
 118
 119 extern "C" {
 120     fn __cxa_allocate_exception(thrown_size: libc::size_t) -> *mut libc::c_void;
 121     fn __cxa_begin_catch(thrown_exception: *mut libc::c_void) -> *mut libc::c_void;
 122     fn __cxa_end_catch();
 123     fn __cxa_throw(
 124         thrown_exception: *mut libc::c_void,
 125         tinfo: *const TypeInfo,
 126         dest: extern "C" fn(*mut libc::c_void) -> *mut libc::c_void,
 127     ) -> !;
 128     fn __gxx_personality_v0(
 129         version: c_int,
 130         actions: uw::_Unwind_Action,
 131         exception_class: uw::_Unwind_Exception_Class,
 132         exception_object: *mut uw::_Unwind_Exception,
 133         context: *mut uw::_Unwind_Context,
 134     ) -> uw::_Unwind_Reason_Code;
 135 }