library/panic_unwind/src/gcc.rs

   1 //! Implementation of panics backed by libgcc/libunwind (in some form).
   2 //!
   3 //! For background on exception handling and stack unwinding please see
   4 //! "Exception Handling in LLVM" (llvm.org/docs/ExceptionHandling.html) and
   5 //! documents linked from it.
   6 //! These are also good reads:
   7 //!  * <https://itanium-cxx-abi.github.io/cxx-abi/abi-eh.html>
   8 //!  * <https://monoinfinito.wordpress.com/series/exception-handling-in-c/>
   9 //!  * <https://www.airs.com/blog/index.php?s=exception+frames>
  10 //!
  11 //! ## A brief summary
  12 //!
  13 //! Exception handling happens in two phases: a search phase and a cleanup
  14 //! phase.
  15 //!
  16 //! In both phases the unwinder walks stack frames from top to bottom using
  17 //! information from the stack frame unwind sections of the current process's
  18 //! modules ("module" here refers to an OS module, i.e., an executable or a
  19 //! dynamic library).
  20 //!
  21 //! For each stack frame, it invokes the associated "personality routine", whose
  22 //! address is also stored in the unwind info section.
  23 //!
  24 //! In the search phase, the job of a personality routine is to examine
  25 //! exception object being thrown, and to decide whether it should be caught at
  26 //! that stack frame. Once the handler frame has been identified, cleanup phase
  27 //! begins.
  28 //!
  29 //! In the cleanup phase, the unwinder invokes each personality routine again.
  30 //! This time it decides which (if any) cleanup code needs to be run for
  31 //! the current stack frame. If so, the control is transferred to a special
  32 //! branch in the function body, the "landing pad", which invokes destructors,
  33 //! frees memory, etc. At the end of the landing pad, control is transferred
  34 //! back to the unwinder and unwinding resumes.
  35 //!
  36 //! Once stack has been unwound down to the handler frame level, unwinding stops
  37 //! and the last personality routine transfers control to the catch block.
  38
  39 use alloc::boxed::Box;
  40 use core::any::Any;
  41 use core::ptr;
  42
  43 use unwind as uw;
  44
  45 // In case where multiple copies of std exist in a single process,
  46 // we use address of this static variable to distinguish an exception raised by
  47 // this copy and some other copy (which needs to be treated as foreign exception).
  48 static CANARY: u8 = 0;
  49
  50 // NOTE(nbdd0121)
  51 // Once `c_unwind` feature is stabilized, there will be ABI stability requirement
  52 // on this struct. The first two field must be `_Unwind_Exception` and `canary`,
  53 // as it may be accessed by a different version of the std with a different compiler.
  54 #[repr(C)]
  55 struct Exception {
  56     _uwe: uw::_Unwind_Exception,
  57     canary: *const u8,
  58     cause: Box<dyn Any + Send>,
  59 }
  60
  61 pub unsafe fn panic(data: Box<dyn Any + Send>) -> u32 {
  62     let exception = Box::new(Exception {
  63         _uwe: uw::_Unwind_Exception {
  64             exception_class: rust_exception_class(),
  65             exception_cleanup,
  66             private: [0; uw::unwinder_private_data_size],
  67         },
  68         canary: &CANARY,
  69         cause: data,
  70     });
  71     let exception_param = Box::into_raw(exception) as *mut uw::_Unwind_Exception;
  72     return uw::_Unwind_RaiseException(exception_param) as u32;
  73
  74     extern "C" fn exception_cleanup(
  75         _unwind_code: uw::_Unwind_Reason_Code,
  76         exception: *mut uw::_Unwind_Exception,
  77     ) {
  78         unsafe {
  79             let _: Box<Exception> = Box::from_raw(exception as *mut Exception);
  80             super::__rust_drop_panic();
  81         }
  82     }
  83 }
  84
  85 pub unsafe fn cleanup(ptr: *mut u8) -> Box<dyn Any + Send> {
  86     let exception = ptr as *mut uw::_Unwind_Exception;
  87     if (*exception).exception_class != rust_exception_class() {
  88         uw::_Unwind_DeleteException(exception);
  89         super::__rust_foreign_exception();
  90     }
  91
  92     let exception = exception.cast::<Exception>();
  93     // Just access the canary field, avoid accessing the entire `Exception` as
  94     // it can be a foreign Rust exception.
  95     let canary = ptr::addr_of!((*exception).canary).read();
  96     if !ptr::eq(canary, &CANARY) {
  97         // A foreign Rust exception, treat it slightly differently from other
  98         // foreign exceptions, because call into `_Unwind_DeleteException` will
  99         // call into `__rust_drop_panic` which produces a confusing
 100         // "Rust panic must be rethrown" message.
 101         super::__rust_foreign_exception();
 102     }
 103
 104     let exception = Box::from_raw(exception as *mut Exception);
 105     exception.cause
 106 }
 107
 108 // Rust's exception class identifier.  This is used by personality routines to
 109 // determine whether the exception was thrown by their own runtime.
 110 fn rust_exception_class() -> uw::_Unwind_Exception_Class {
 111     // M O Z \0  R U S T -- vendor, language
 112     0x4d4f5a_00_52555354
 113 }