summaryrefslogtreecommitdiffstats
path: root/vendor/backtrace/src
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/backtrace/src')
-rw-r--r--vendor/backtrace/src/android-api.c4
-rw-r--r--vendor/backtrace/src/backtrace/dbghelp.rs257
-rw-r--r--vendor/backtrace/src/backtrace/libunwind.rs267
-rw-r--r--vendor/backtrace/src/backtrace/miri.rs107
-rw-r--r--vendor/backtrace/src/backtrace/mod.rs162
-rw-r--r--vendor/backtrace/src/backtrace/noop.rs28
-rw-r--r--vendor/backtrace/src/capture.rs555
-rw-r--r--vendor/backtrace/src/dbghelp.rs351
-rw-r--r--vendor/backtrace/src/lib.rs193
-rw-r--r--vendor/backtrace/src/print.rs302
-rw-r--r--vendor/backtrace/src/print/fuchsia.rs436
-rw-r--r--vendor/backtrace/src/symbolize/dbghelp.rs218
-rw-r--r--vendor/backtrace/src/symbolize/gimli.rs462
-rw-r--r--vendor/backtrace/src/symbolize/gimli/coff.rs108
-rw-r--r--vendor/backtrace/src/symbolize/gimli/elf.rs423
-rw-r--r--vendor/backtrace/src/symbolize/gimli/libs_dl_iterate_phdr.rs53
-rw-r--r--vendor/backtrace/src/symbolize/gimli/libs_haiku.rs48
-rw-r--r--vendor/backtrace/src/symbolize/gimli/libs_illumos.rs99
-rw-r--r--vendor/backtrace/src/symbolize/gimli/libs_libnx.rs27
-rw-r--r--vendor/backtrace/src/symbolize/gimli/libs_macos.rs146
-rw-r--r--vendor/backtrace/src/symbolize/gimli/libs_windows.rs89
-rw-r--r--vendor/backtrace/src/symbolize/gimli/macho.rs324
-rw-r--r--vendor/backtrace/src/symbolize/gimli/mmap_fake.rs25
-rw-r--r--vendor/backtrace/src/symbolize/gimli/mmap_unix.rs44
-rw-r--r--vendor/backtrace/src/symbolize/gimli/mmap_windows.rs57
-rw-r--r--vendor/backtrace/src/symbolize/gimli/stash.rs52
-rw-r--r--vendor/backtrace/src/symbolize/miri.rs56
-rw-r--r--vendor/backtrace/src/symbolize/mod.rs485
-rw-r--r--vendor/backtrace/src/symbolize/noop.rs41
-rw-r--r--vendor/backtrace/src/types.rs83
-rw-r--r--vendor/backtrace/src/windows.rs691
31 files changed, 6193 insertions, 0 deletions
diff --git a/vendor/backtrace/src/android-api.c b/vendor/backtrace/src/android-api.c
new file mode 100644
index 000000000..1bfeadf5b
--- /dev/null
+++ b/vendor/backtrace/src/android-api.c
@@ -0,0 +1,4 @@
+// Used from the build script to detect the value of the `__ANDROID_API__`
+// builtin #define
+
+APIVERSION __ANDROID_API__
diff --git a/vendor/backtrace/src/backtrace/dbghelp.rs b/vendor/backtrace/src/backtrace/dbghelp.rs
new file mode 100644
index 000000000..ba0f05f3b
--- /dev/null
+++ b/vendor/backtrace/src/backtrace/dbghelp.rs
@@ -0,0 +1,257 @@
+//! Backtrace strategy for MSVC platforms.
+//!
+//! This module contains the ability to generate a backtrace on MSVC using one
+//! of two possible methods. The `StackWalkEx` function is primarily used if
+//! possible, but not all systems have that. Failing that the `StackWalk64`
+//! function is used instead. Note that `StackWalkEx` is favored because it
+//! handles debuginfo internally and returns inline frame information.
+//!
+//! Note that all dbghelp support is loaded dynamically, see `src/dbghelp.rs`
+//! for more information about that.
+
+#![allow(bad_style)]
+
+use super::super::{dbghelp, windows::*};
+use core::ffi::c_void;
+use core::mem;
+
+#[derive(Clone, Copy)]
+pub enum StackFrame {
+ New(STACKFRAME_EX),
+ Old(STACKFRAME64),
+}
+
+#[derive(Clone, Copy)]
+pub struct Frame {
+ pub(crate) stack_frame: StackFrame,
+ base_address: *mut c_void,
+}
+
+// we're just sending around raw pointers and reading them, never interpreting
+// them so this should be safe to both send and share across threads.
+unsafe impl Send for Frame {}
+unsafe impl Sync for Frame {}
+
+impl Frame {
+ pub fn ip(&self) -> *mut c_void {
+ self.addr_pc().Offset as *mut _
+ }
+
+ pub fn sp(&self) -> *mut c_void {
+ self.addr_stack().Offset as *mut _
+ }
+
+ pub fn symbol_address(&self) -> *mut c_void {
+ self.ip()
+ }
+
+ pub fn module_base_address(&self) -> Option<*mut c_void> {
+ Some(self.base_address)
+ }
+
+ fn addr_pc(&self) -> &ADDRESS64 {
+ match self.stack_frame {
+ StackFrame::New(ref new) => &new.AddrPC,
+ StackFrame::Old(ref old) => &old.AddrPC,
+ }
+ }
+
+ fn addr_pc_mut(&mut self) -> &mut ADDRESS64 {
+ match self.stack_frame {
+ StackFrame::New(ref mut new) => &mut new.AddrPC,
+ StackFrame::Old(ref mut old) => &mut old.AddrPC,
+ }
+ }
+
+ fn addr_frame_mut(&mut self) -> &mut ADDRESS64 {
+ match self.stack_frame {
+ StackFrame::New(ref mut new) => &mut new.AddrFrame,
+ StackFrame::Old(ref mut old) => &mut old.AddrFrame,
+ }
+ }
+
+ fn addr_stack(&self) -> &ADDRESS64 {
+ match self.stack_frame {
+ StackFrame::New(ref new) => &new.AddrStack,
+ StackFrame::Old(ref old) => &old.AddrStack,
+ }
+ }
+
+ fn addr_stack_mut(&mut self) -> &mut ADDRESS64 {
+ match self.stack_frame {
+ StackFrame::New(ref mut new) => &mut new.AddrStack,
+ StackFrame::Old(ref mut old) => &mut old.AddrStack,
+ }
+ }
+}
+
+#[repr(C, align(16))] // required by `CONTEXT`, is a FIXME in winapi right now
+struct MyContext(CONTEXT);
+
+#[inline(always)]
+pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
+ // Allocate necessary structures for doing the stack walk
+ let process = GetCurrentProcess();
+ let thread = GetCurrentThread();
+
+ let mut context = mem::zeroed::<MyContext>();
+ RtlCaptureContext(&mut context.0);
+
+ // Ensure this process's symbols are initialized
+ let dbghelp = match dbghelp::init() {
+ Ok(dbghelp) => dbghelp,
+ Err(()) => return, // oh well...
+ };
+
+ // On x86_64 and ARM64 we opt to not use the default `Sym*` functions from
+ // dbghelp for getting the function table and module base. Instead we use
+ // the `RtlLookupFunctionEntry` function in kernel32 which will account for
+ // JIT compiler frames as well. These should be equivalent, but using
+ // `Rtl*` allows us to backtrace through JIT frames.
+ //
+ // Note that `RtlLookupFunctionEntry` only works for in-process backtraces,
+ // but that's all we support anyway, so it all lines up well.
+ cfg_if::cfg_if! {
+ if #[cfg(target_pointer_width = "64")] {
+ use core::ptr;
+
+ unsafe extern "system" fn function_table_access(_process: HANDLE, addr: DWORD64) -> PVOID {
+ let mut base = 0;
+ RtlLookupFunctionEntry(addr, &mut base, ptr::null_mut()).cast()
+ }
+
+ unsafe extern "system" fn get_module_base(_process: HANDLE, addr: DWORD64) -> DWORD64 {
+ let mut base = 0;
+ RtlLookupFunctionEntry(addr, &mut base, ptr::null_mut());
+ base
+ }
+ } else {
+ let function_table_access = dbghelp.SymFunctionTableAccess64();
+ let get_module_base = dbghelp.SymGetModuleBase64();
+ }
+ }
+
+ let process_handle = GetCurrentProcess();
+
+ // Attempt to use `StackWalkEx` if we can, but fall back to `StackWalk64`
+ // since it's in theory supported on more systems.
+ match (*dbghelp.dbghelp()).StackWalkEx() {
+ Some(StackWalkEx) => {
+ let mut inner: STACKFRAME_EX = mem::zeroed();
+ inner.StackFrameSize = mem::size_of::<STACKFRAME_EX>() as DWORD;
+ let mut frame = super::Frame {
+ inner: Frame {
+ stack_frame: StackFrame::New(inner),
+ base_address: 0 as _,
+ },
+ };
+ let image = init_frame(&mut frame.inner, &context.0);
+ let frame_ptr = match &mut frame.inner.stack_frame {
+ StackFrame::New(ptr) => ptr as *mut STACKFRAME_EX,
+ _ => unreachable!(),
+ };
+
+ while StackWalkEx(
+ image as DWORD,
+ process,
+ thread,
+ frame_ptr,
+ &mut context.0 as *mut CONTEXT as *mut _,
+ None,
+ Some(function_table_access),
+ Some(get_module_base),
+ None,
+ 0,
+ ) == TRUE
+ {
+ frame.inner.base_address = get_module_base(process_handle, frame.ip() as _) as _;
+
+ if !cb(&frame) {
+ break;
+ }
+ }
+ }
+ None => {
+ let mut frame = super::Frame {
+ inner: Frame {
+ stack_frame: StackFrame::Old(mem::zeroed()),
+ base_address: 0 as _,
+ },
+ };
+ let image = init_frame(&mut frame.inner, &context.0);
+ let frame_ptr = match &mut frame.inner.stack_frame {
+ StackFrame::Old(ptr) => ptr as *mut STACKFRAME64,
+ _ => unreachable!(),
+ };
+
+ while dbghelp.StackWalk64()(
+ image as DWORD,
+ process,
+ thread,
+ frame_ptr,
+ &mut context.0 as *mut CONTEXT as *mut _,
+ None,
+ Some(function_table_access),
+ Some(get_module_base),
+ None,
+ ) == TRUE
+ {
+ frame.inner.base_address = get_module_base(process_handle, frame.ip() as _) as _;
+
+ if !cb(&frame) {
+ break;
+ }
+ }
+ }
+ }
+}
+
+#[cfg(target_arch = "x86_64")]
+fn init_frame(frame: &mut Frame, ctx: &CONTEXT) -> WORD {
+ frame.addr_pc_mut().Offset = ctx.Rip as u64;
+ frame.addr_pc_mut().Mode = AddrModeFlat;
+ frame.addr_stack_mut().Offset = ctx.Rsp as u64;
+ frame.addr_stack_mut().Mode = AddrModeFlat;
+ frame.addr_frame_mut().Offset = ctx.Rbp as u64;
+ frame.addr_frame_mut().Mode = AddrModeFlat;
+
+ IMAGE_FILE_MACHINE_AMD64
+}
+
+#[cfg(target_arch = "x86")]
+fn init_frame(frame: &mut Frame, ctx: &CONTEXT) -> WORD {
+ frame.addr_pc_mut().Offset = ctx.Eip as u64;
+ frame.addr_pc_mut().Mode = AddrModeFlat;
+ frame.addr_stack_mut().Offset = ctx.Esp as u64;
+ frame.addr_stack_mut().Mode = AddrModeFlat;
+ frame.addr_frame_mut().Offset = ctx.Ebp as u64;
+ frame.addr_frame_mut().Mode = AddrModeFlat;
+
+ IMAGE_FILE_MACHINE_I386
+}
+
+#[cfg(target_arch = "aarch64")]
+fn init_frame(frame: &mut Frame, ctx: &CONTEXT) -> WORD {
+ frame.addr_pc_mut().Offset = ctx.Pc as u64;
+ frame.addr_pc_mut().Mode = AddrModeFlat;
+ frame.addr_stack_mut().Offset = ctx.Sp as u64;
+ frame.addr_stack_mut().Mode = AddrModeFlat;
+ unsafe {
+ frame.addr_frame_mut().Offset = ctx.u.s().Fp as u64;
+ }
+ frame.addr_frame_mut().Mode = AddrModeFlat;
+ IMAGE_FILE_MACHINE_ARM64
+}
+
+#[cfg(target_arch = "arm")]
+fn init_frame(frame: &mut Frame, ctx: &CONTEXT) -> WORD {
+ frame.addr_pc_mut().Offset = ctx.Pc as u64;
+ frame.addr_pc_mut().Mode = AddrModeFlat;
+ frame.addr_stack_mut().Offset = ctx.Sp as u64;
+ frame.addr_stack_mut().Mode = AddrModeFlat;
+ unsafe {
+ frame.addr_frame_mut().Offset = ctx.R11 as u64;
+ }
+ frame.addr_frame_mut().Mode = AddrModeFlat;
+ IMAGE_FILE_MACHINE_ARMNT
+}
diff --git a/vendor/backtrace/src/backtrace/libunwind.rs b/vendor/backtrace/src/backtrace/libunwind.rs
new file mode 100644
index 000000000..ef77edda5
--- /dev/null
+++ b/vendor/backtrace/src/backtrace/libunwind.rs
@@ -0,0 +1,267 @@
+//! Backtrace support using libunwind/gcc_s/etc APIs.
+//!
+//! This module contains the ability to unwind the stack using libunwind-style
+//! APIs. Note that there's a whole bunch of implementations of the
+//! libunwind-like API, and this is just trying to be compatible with most of
+//! them all at once instead of being picky.
+//!
+//! The libunwind API is powered by `_Unwind_Backtrace` and is in practice very
+//! reliable at generating a backtrace. It's not entirely clear how it does it
+//! (frame pointers? eh_frame info? both?) but it seems to work!
+//!
+//! Most of the complexity of this module is handling the various platform
+//! differences across libunwind implementations. Otherwise this is a pretty
+//! straightforward Rust binding to the libunwind APIs.
+//!
+//! This is the default unwinding API for all non-Windows platforms currently.
+
+use super::super::Bomb;
+use core::ffi::c_void;
+
+pub enum Frame {
+ Raw(*mut uw::_Unwind_Context),
+ Cloned {
+ ip: *mut c_void,
+ sp: *mut c_void,
+ symbol_address: *mut c_void,
+ },
+}
+
+// With a raw libunwind pointer it should only ever be access in a readonly
+// threadsafe fashion, so it's `Sync`. When sending to other threads via `Clone`
+// we always switch to a version which doesn't retain interior pointers, so we
+// should be `Send` as well.
+unsafe impl Send for Frame {}
+unsafe impl Sync for Frame {}
+
+impl Frame {
+ pub fn ip(&self) -> *mut c_void {
+ let ctx = match *self {
+ Frame::Raw(ctx) => ctx,
+ Frame::Cloned { ip, .. } => return ip,
+ };
+ unsafe { uw::_Unwind_GetIP(ctx) as *mut c_void }
+ }
+
+ pub fn sp(&self) -> *mut c_void {
+ match *self {
+ Frame::Raw(ctx) => unsafe { uw::get_sp(ctx) as *mut c_void },
+ Frame::Cloned { sp, .. } => sp,
+ }
+ }
+
+ pub fn symbol_address(&self) -> *mut c_void {
+ if let Frame::Cloned { symbol_address, .. } = *self {
+ return symbol_address;
+ }
+
+ // The macOS linker emits a "compact" unwind table that only includes an
+ // entry for a function if that function either has an LSDA or its
+ // encoding differs from that of the previous entry. Consequently, on
+ // macOS, `_Unwind_FindEnclosingFunction` is unreliable (it can return a
+ // pointer to some totally unrelated function). Instead, we just always
+ // return the ip.
+ //
+ // https://github.com/rust-lang/rust/issues/74771#issuecomment-664056788
+ //
+ // Note the `skip_inner_frames.rs` test is skipped on macOS due to this
+ // clause, and if this is fixed that test in theory can be run on macOS!
+ if cfg!(target_os = "macos") || cfg!(target_os = "ios") {
+ self.ip()
+ } else {
+ unsafe { uw::_Unwind_FindEnclosingFunction(self.ip()) }
+ }
+ }
+
+ pub fn module_base_address(&self) -> Option<*mut c_void> {
+ None
+ }
+}
+
+impl Clone for Frame {
+ fn clone(&self) -> Frame {
+ Frame::Cloned {
+ ip: self.ip(),
+ sp: self.sp(),
+ symbol_address: self.symbol_address(),
+ }
+ }
+}
+
+#[inline(always)]
+pub unsafe fn trace(mut cb: &mut dyn FnMut(&super::Frame) -> bool) {
+ uw::_Unwind_Backtrace(trace_fn, &mut cb as *mut _ as *mut _);
+
+ extern "C" fn trace_fn(
+ ctx: *mut uw::_Unwind_Context,
+ arg: *mut c_void,
+ ) -> uw::_Unwind_Reason_Code {
+ let cb = unsafe { &mut *(arg as *mut &mut dyn FnMut(&super::Frame) -> bool) };
+ let cx = super::Frame {
+ inner: Frame::Raw(ctx),
+ };
+
+ let mut bomb = Bomb { enabled: true };
+ let keep_going = cb(&cx);
+ bomb.enabled = false;
+
+ if keep_going {
+ uw::_URC_NO_REASON
+ } else {
+ uw::_URC_FAILURE
+ }
+ }
+}
+
+/// Unwind library interface used for backtraces
+///
+/// Note that dead code is allowed as here are just bindings
+/// iOS doesn't use all of them it but adding more
+/// platform-specific configs pollutes the code too much
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[allow(dead_code)]
+mod uw {
+ pub use self::_Unwind_Reason_Code::*;
+
+ use core::ffi::c_void;
+
+ #[repr(C)]
+ pub enum _Unwind_Reason_Code {
+ _URC_NO_REASON = 0,
+ _URC_FOREIGN_EXCEPTION_CAUGHT = 1,
+ _URC_FATAL_PHASE2_ERROR = 2,
+ _URC_FATAL_PHASE1_ERROR = 3,
+ _URC_NORMAL_STOP = 4,
+ _URC_END_OF_STACK = 5,
+ _URC_HANDLER_FOUND = 6,
+ _URC_INSTALL_CONTEXT = 7,
+ _URC_CONTINUE_UNWIND = 8,
+ _URC_FAILURE = 9, // used only by ARM EABI
+ }
+
+ pub enum _Unwind_Context {}
+
+ pub type _Unwind_Trace_Fn =
+ extern "C" fn(ctx: *mut _Unwind_Context, arg: *mut c_void) -> _Unwind_Reason_Code;
+
+ extern "C" {
+ pub fn _Unwind_Backtrace(
+ trace: _Unwind_Trace_Fn,
+ trace_argument: *mut c_void,
+ ) -> _Unwind_Reason_Code;
+ }
+
+ cfg_if::cfg_if! {
+ // available since GCC 4.2.0, should be fine for our purpose
+ if #[cfg(all(
+ not(all(target_os = "android", target_arch = "arm")),
+ not(all(target_os = "freebsd", target_arch = "arm")),
+ not(all(target_os = "linux", target_arch = "arm")),
+ not(all(target_os = "horizon", target_arch = "arm"))
+ ))] {
+ extern "C" {
+ pub fn _Unwind_GetIP(ctx: *mut _Unwind_Context) -> libc::uintptr_t;
+ pub fn _Unwind_FindEnclosingFunction(pc: *mut c_void) -> *mut c_void;
+
+ #[cfg(not(all(target_os = "linux", target_arch = "s390x")))]
+ // This function is a misnomer: rather than getting this frame's
+ // Canonical Frame Address (aka the caller frame's SP) it
+ // returns this frame's SP.
+ //
+ // https://github.com/libunwind/libunwind/blob/d32956507cf29d9b1a98a8bce53c78623908f4fe/src/unwind/GetCFA.c#L28-L35
+ #[link_name = "_Unwind_GetCFA"]
+ pub fn get_sp(ctx: *mut _Unwind_Context) -> libc::uintptr_t;
+
+ }
+
+ // s390x uses a biased CFA value, therefore we need to use
+ // _Unwind_GetGR to get the stack pointer register (%r15)
+ // instead of relying on _Unwind_GetCFA.
+ #[cfg(all(target_os = "linux", target_arch = "s390x"))]
+ pub unsafe fn get_sp(ctx: *mut _Unwind_Context) -> libc::uintptr_t {
+ extern "C" {
+ pub fn _Unwind_GetGR(ctx: *mut _Unwind_Context, index: libc::c_int) -> libc::uintptr_t;
+ }
+ _Unwind_GetGR(ctx, 15)
+ }
+ } else {
+ // On android and arm, the function `_Unwind_GetIP` and a bunch of
+ // others are macros, so we define functions containing the
+ // expansion of the macros.
+ //
+ // TODO: link to the header file that defines these macros, if you
+ // can find it. (I, fitzgen, cannot find the header file that some
+ // of these macro expansions were originally borrowed from.)
+ #[repr(C)]
+ enum _Unwind_VRS_Result {
+ _UVRSR_OK = 0,
+ _UVRSR_NOT_IMPLEMENTED = 1,
+ _UVRSR_FAILED = 2,
+ }
+ #[repr(C)]
+ enum _Unwind_VRS_RegClass {
+ _UVRSC_CORE = 0,
+ _UVRSC_VFP = 1,
+ _UVRSC_FPA = 2,
+ _UVRSC_WMMXD = 3,
+ _UVRSC_WMMXC = 4,
+ }
+ #[repr(C)]
+ enum _Unwind_VRS_DataRepresentation {
+ _UVRSD_UINT32 = 0,
+ _UVRSD_VFPX = 1,
+ _UVRSD_FPAX = 2,
+ _UVRSD_UINT64 = 3,
+ _UVRSD_FLOAT = 4,
+ _UVRSD_DOUBLE = 5,
+ }
+
+ type _Unwind_Word = libc::c_uint;
+ extern "C" {
+ fn _Unwind_VRS_Get(
+ ctx: *mut _Unwind_Context,
+ klass: _Unwind_VRS_RegClass,
+ word: _Unwind_Word,
+ repr: _Unwind_VRS_DataRepresentation,
+ data: *mut c_void,
+ ) -> _Unwind_VRS_Result;
+ }
+
+ pub unsafe fn _Unwind_GetIP(ctx: *mut _Unwind_Context) -> libc::uintptr_t {
+ let mut val: _Unwind_Word = 0;
+ let ptr = &mut val as *mut _Unwind_Word;
+ let _ = _Unwind_VRS_Get(
+ ctx,
+ _Unwind_VRS_RegClass::_UVRSC_CORE,
+ 15,
+ _Unwind_VRS_DataRepresentation::_UVRSD_UINT32,
+ ptr as *mut c_void,
+ );
+ (val & !1) as libc::uintptr_t
+ }
+
+ // R13 is the stack pointer on arm.
+ const SP: _Unwind_Word = 13;
+
+ pub unsafe fn get_sp(ctx: *mut _Unwind_Context) -> libc::uintptr_t {
+ let mut val: _Unwind_Word = 0;
+ let ptr = &mut val as *mut _Unwind_Word;
+ let _ = _Unwind_VRS_Get(
+ ctx,
+ _Unwind_VRS_RegClass::_UVRSC_CORE,
+ SP,
+ _Unwind_VRS_DataRepresentation::_UVRSD_UINT32,
+ ptr as *mut c_void,
+ );
+ val as libc::uintptr_t
+ }
+
+ // This function also doesn't exist on Android or ARM/Linux, so make it
+ // a no-op.
+ pub unsafe fn _Unwind_FindEnclosingFunction(pc: *mut c_void) -> *mut c_void {
+ pc
+ }
+ }
+ }
+}
diff --git a/vendor/backtrace/src/backtrace/miri.rs b/vendor/backtrace/src/backtrace/miri.rs
new file mode 100644
index 000000000..9a5f65b80
--- /dev/null
+++ b/vendor/backtrace/src/backtrace/miri.rs
@@ -0,0 +1,107 @@
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::ffi::c_void;
+
+extern "Rust" {
+ fn miri_backtrace_size(flags: u64) -> usize;
+ fn miri_get_backtrace(flags: u64, buf: *mut *mut ());
+ fn miri_resolve_frame(ptr: *mut (), flags: u64) -> MiriFrame;
+ fn miri_resolve_frame_names(ptr: *mut (), flags: u64, name_buf: *mut u8, filename_buf: *mut u8);
+}
+
+#[repr(C)]
+pub struct MiriFrame {
+ pub name_len: usize,
+ pub filename_len: usize,
+ pub lineno: u32,
+ pub colno: u32,
+ pub fn_ptr: *mut c_void,
+}
+
+#[derive(Clone, Debug)]
+pub struct FullMiriFrame {
+ pub name: Box<[u8]>,
+ pub filename: Box<[u8]>,
+ pub lineno: u32,
+ pub colno: u32,
+ pub fn_ptr: *mut c_void,
+}
+
+#[derive(Debug, Clone)]
+pub struct Frame {
+ pub addr: *mut c_void,
+ pub inner: FullMiriFrame,
+}
+
+// SAFETY: Miri guarantees that the returned pointer
+// can be used from any thread.
+unsafe impl Send for Frame {}
+unsafe impl Sync for Frame {}
+
+impl Frame {
+ pub fn ip(&self) -> *mut c_void {
+ self.addr
+ }
+
+ pub fn sp(&self) -> *mut c_void {
+ core::ptr::null_mut()
+ }
+
+ pub fn symbol_address(&self) -> *mut c_void {
+ self.inner.fn_ptr
+ }
+
+ pub fn module_base_address(&self) -> Option<*mut c_void> {
+ None
+ }
+}
+
+pub fn trace<F: FnMut(&super::Frame) -> bool>(cb: F) {
+ // SAFETY: Miri guarantees that the backtrace API functions
+ // can be called from any thread.
+ unsafe { trace_unsynchronized(cb) };
+}
+
+pub fn resolve_addr(ptr: *mut c_void) -> Frame {
+ // SAFETY: Miri will stop execution with an error if this pointer
+ // is invalid.
+ let frame = unsafe { miri_resolve_frame(ptr as *mut (), 1) };
+
+ let mut name = Vec::with_capacity(frame.name_len);
+ let mut filename = Vec::with_capacity(frame.filename_len);
+
+ // SAFETY: name and filename have been allocated with the amount
+ // of memory miri has asked for, and miri guarantees it will initialize it
+ unsafe {
+ miri_resolve_frame_names(ptr as *mut (), 0, name.as_mut_ptr(), filename.as_mut_ptr());
+
+ name.set_len(frame.name_len);
+ filename.set_len(frame.filename_len);
+ }
+
+ Frame {
+ addr: ptr,
+ inner: FullMiriFrame {
+ name: name.into(),
+ filename: filename.into(),
+ lineno: frame.lineno,
+ colno: frame.colno,
+ fn_ptr: frame.fn_ptr,
+ },
+ }
+}
+
+pub unsafe fn trace_unsynchronized<F: FnMut(&super::Frame) -> bool>(mut cb: F) {
+ let len = miri_backtrace_size(0);
+
+ let mut frames = Vec::with_capacity(len);
+
+ miri_get_backtrace(1, frames.as_mut_ptr());
+
+ frames.set_len(len);
+
+ for ptr in frames.iter() {
+ let frame = resolve_addr(*ptr as *mut c_void);
+ cb(&super::Frame { inner: frame });
+ }
+}
diff --git a/vendor/backtrace/src/backtrace/mod.rs b/vendor/backtrace/src/backtrace/mod.rs
new file mode 100644
index 000000000..93355d744
--- /dev/null
+++ b/vendor/backtrace/src/backtrace/mod.rs
@@ -0,0 +1,162 @@
+use core::ffi::c_void;
+use core::fmt;
+
+/// Inspects the current call-stack, passing all active frames into the closure
+/// provided to calculate a stack trace.
+///
+/// This function is the workhorse of this library in calculating the stack
+/// traces for a program. The given closure `cb` is yielded instances of a
+/// `Frame` which represent information about that call frame on the stack. The
+/// closure is yielded frames in a top-down fashion (most recently called
+/// functions first).
+///
+/// The closure's return value is an indication of whether the backtrace should
+/// continue. A return value of `false` will terminate the backtrace and return
+/// immediately.
+///
+/// Once a `Frame` is acquired you will likely want to call `backtrace::resolve`
+/// to convert the `ip` (instruction pointer) or symbol address to a `Symbol`
+/// through which the name and/or filename/line number can be learned.
+///
+/// Note that this is a relatively low-level function and if you'd like to, for
+/// example, capture a backtrace to be inspected later, then the `Backtrace`
+/// type may be more appropriate.
+///
+/// # Required features
+///
+/// This function requires the `std` feature of the `backtrace` crate to be
+/// enabled, and the `std` feature is enabled by default.
+///
+/// # Panics
+///
+/// This function strives to never panic, but if the `cb` provided panics then
+/// some platforms will force a double panic to abort the process. Some
+/// platforms use a C library which internally uses callbacks which cannot be
+/// unwound through, so panicking from `cb` may trigger a process abort.
+///
+/// # Example
+///
+/// ```
+/// extern crate backtrace;
+///
+/// fn main() {
+/// backtrace::trace(|frame| {
+/// // ...
+///
+/// true // continue the backtrace
+/// });
+/// }
+/// ```
+#[cfg(feature = "std")]
+pub fn trace<F: FnMut(&Frame) -> bool>(cb: F) {
+ let _guard = crate::lock::lock();
+ unsafe { trace_unsynchronized(cb) }
+}
+
+/// Same as `trace`, only unsafe as it's unsynchronized.
+///
+/// This function does not have synchronization guarantees but is available
+/// when the `std` feature of this crate isn't compiled in. See the `trace`
+/// function for more documentation and examples.
+///
+/// # Panics
+///
+/// See information on `trace` for caveats on `cb` panicking.
+pub unsafe fn trace_unsynchronized<F: FnMut(&Frame) -> bool>(mut cb: F) {
+ trace_imp(&mut cb)
+}
+
+/// A trait representing one frame of a backtrace, yielded to the `trace`
+/// function of this crate.
+///
+/// The tracing function's closure will be yielded frames, and the frame is
+/// virtually dispatched as the underlying implementation is not always known
+/// until runtime.
+#[derive(Clone)]
+pub struct Frame {
+ pub(crate) inner: FrameImp,
+}
+
+impl Frame {
+ /// Returns the current instruction pointer of this frame.
+ ///
+ /// This is normally the next instruction to execute in the frame, but not
+ /// all implementations list this with 100% accuracy (but it's generally
+ /// pretty close).
+ ///
+ /// It is recommended to pass this value to `backtrace::resolve` to turn it
+ /// into a symbol name.
+ pub fn ip(&self) -> *mut c_void {
+ self.inner.ip()
+ }
+
+ /// Returns the current stack pointer of this frame.
+ ///
+ /// In the case that a backend cannot recover the stack pointer for this
+ /// frame, a null pointer is returned.
+ pub fn sp(&self) -> *mut c_void {
+ self.inner.sp()
+ }
+
+ /// Returns the starting symbol address of the frame of this function.
+ ///
+ /// This will attempt to rewind the instruction pointer returned by `ip` to
+ /// the start of the function, returning that value. In some cases, however,
+ /// backends will just return `ip` from this function.
+ ///
+ /// The returned value can sometimes be used if `backtrace::resolve` failed
+ /// on the `ip` given above.
+ pub fn symbol_address(&self) -> *mut c_void {
+ self.inner.symbol_address()
+ }
+
+ /// Returns the base address of the module to which the frame belongs.
+ pub fn module_base_address(&self) -> Option<*mut c_void> {
+ self.inner.module_base_address()
+ }
+}
+
+impl fmt::Debug for Frame {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("Frame")
+ .field("ip", &self.ip())
+ .field("symbol_address", &self.symbol_address())
+ .finish()
+ }
+}
+
+cfg_if::cfg_if! {
+ // This needs to come first, to ensure that
+ // Miri takes priority over the host platform
+ if #[cfg(miri)] {
+ pub(crate) mod miri;
+ use self::miri::trace as trace_imp;
+ pub(crate) use self::miri::Frame as FrameImp;
+ } else if #[cfg(
+ any(
+ all(
+ unix,
+ not(target_os = "emscripten"),
+ not(all(target_os = "ios", target_arch = "arm")),
+ ),
+ all(
+ target_env = "sgx",
+ target_vendor = "fortanix",
+ ),
+ )
+ )] {
+ mod libunwind;
+ use self::libunwind::trace as trace_imp;
+ pub(crate) use self::libunwind::Frame as FrameImp;
+ } else if #[cfg(all(windows, not(target_vendor = "uwp")))] {
+ mod dbghelp;
+ use self::dbghelp::trace as trace_imp;
+ pub(crate) use self::dbghelp::Frame as FrameImp;
+ #[cfg(target_env = "msvc")] // only used in dbghelp symbolize
+ pub(crate) use self::dbghelp::StackFrame;
+ } else {
+ mod noop;
+ use self::noop::trace as trace_imp;
+ pub(crate) use self::noop::Frame as FrameImp;
+ }
+}
diff --git a/vendor/backtrace/src/backtrace/noop.rs b/vendor/backtrace/src/backtrace/noop.rs
new file mode 100644
index 000000000..7bcea67aa
--- /dev/null
+++ b/vendor/backtrace/src/backtrace/noop.rs
@@ -0,0 +1,28 @@
+//! Empty implementation of unwinding used when no other implementation is
+//! appropriate.
+
+use core::ffi::c_void;
+
+#[inline(always)]
+pub fn trace(_cb: &mut dyn FnMut(&super::Frame) -> bool) {}
+
+#[derive(Clone)]
+pub struct Frame;
+
+impl Frame {
+ pub fn ip(&self) -> *mut c_void {
+ 0 as *mut _
+ }
+
+ pub fn sp(&self) -> *mut c_void {
+ 0 as *mut _
+ }
+
+ pub fn symbol_address(&self) -> *mut c_void {
+ 0 as *mut _
+ }
+
+ pub fn module_base_address(&self) -> Option<*mut c_void> {
+ None
+ }
+}
diff --git a/vendor/backtrace/src/capture.rs b/vendor/backtrace/src/capture.rs
new file mode 100644
index 000000000..e0dd9c474
--- /dev/null
+++ b/vendor/backtrace/src/capture.rs
@@ -0,0 +1,555 @@
+use crate::PrintFmt;
+use crate::{resolve, resolve_frame, trace, BacktraceFmt, Symbol, SymbolName};
+use std::ffi::c_void;
+use std::fmt;
+use std::path::{Path, PathBuf};
+use std::prelude::v1::*;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+/// Representation of an owned and self-contained backtrace.
+///
+/// This structure can be used to capture a backtrace at various points in a
+/// program and later used to inspect what the backtrace was at that time.
+///
+/// `Backtrace` supports pretty-printing of backtraces through its `Debug`
+/// implementation.
+///
+/// # Required features
+///
+/// This function requires the `std` feature of the `backtrace` crate to be
+/// enabled, and the `std` feature is enabled by default.
+#[derive(Clone)]
+#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct Backtrace {
+ // Frames here are listed from top-to-bottom of the stack
+ frames: Vec<BacktraceFrame>,
+ // The index we believe is the actual start of the backtrace, omitting
+ // frames like `Backtrace::new` and `backtrace::trace`.
+ actual_start_index: usize,
+}
+
+fn _assert_send_sync() {
+ fn _assert<T: Send + Sync>() {}
+ _assert::<Backtrace>();
+}
+
+/// Captured version of a frame in a backtrace.
+///
+/// This type is returned as a list from `Backtrace::frames` and represents one
+/// stack frame in a captured backtrace.
+///
+/// # Required features
+///
+/// This function requires the `std` feature of the `backtrace` crate to be
+/// enabled, and the `std` feature is enabled by default.
+#[derive(Clone)]
+pub struct BacktraceFrame {
+ frame: Frame,
+ symbols: Option<Vec<BacktraceSymbol>>,
+}
+
+#[derive(Clone)]
+enum Frame {
+ Raw(crate::Frame),
+ #[allow(dead_code)]
+ Deserialized {
+ ip: usize,
+ symbol_address: usize,
+ module_base_address: Option<usize>,
+ },
+}
+
+impl Frame {
+ fn ip(&self) -> *mut c_void {
+ match *self {
+ Frame::Raw(ref f) => f.ip(),
+ Frame::Deserialized { ip, .. } => ip as *mut c_void,
+ }
+ }
+
+ fn symbol_address(&self) -> *mut c_void {
+ match *self {
+ Frame::Raw(ref f) => f.symbol_address(),
+ Frame::Deserialized { symbol_address, .. } => symbol_address as *mut c_void,
+ }
+ }
+
+ fn module_base_address(&self) -> Option<*mut c_void> {
+ match *self {
+ Frame::Raw(ref f) => f.module_base_address(),
+ Frame::Deserialized {
+ module_base_address,
+ ..
+ } => module_base_address.map(|addr| addr as *mut c_void),
+ }
+ }
+}
+
+/// Captured version of a symbol in a backtrace.
+///
+/// This type is returned as a list from `BacktraceFrame::symbols` and
+/// represents the metadata for a symbol in a backtrace.
+///
+/// # Required features
+///
+/// This function requires the `std` feature of the `backtrace` crate to be
+/// enabled, and the `std` feature is enabled by default.
+#[derive(Clone)]
+#[cfg_attr(feature = "serialize-rustc", derive(RustcDecodable, RustcEncodable))]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+pub struct BacktraceSymbol {
+ name: Option<Vec<u8>>,
+ addr: Option<usize>,
+ filename: Option<PathBuf>,
+ lineno: Option<u32>,
+ colno: Option<u32>,
+}
+
+impl Backtrace {
+ /// Captures a backtrace at the callsite of this function, returning an
+ /// owned representation.
+ ///
+ /// This function is useful for representing a backtrace as an object in
+ /// Rust. This returned value can be sent across threads and printed
+ /// elsewhere, and the purpose of this value is to be entirely self
+ /// contained.
+ ///
+ /// Note that on some platforms acquiring a full backtrace and resolving it
+ /// can be extremely expensive. If the cost is too much for your application
+ /// it's recommended to instead use `Backtrace::new_unresolved()` which
+ /// avoids the symbol resolution step (which typically takes the longest)
+ /// and allows deferring that to a later date.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use backtrace::Backtrace;
+ ///
+ /// let current_backtrace = Backtrace::new();
+ /// ```
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ #[inline(never)] // want to make sure there's a frame here to remove
+ pub fn new() -> Backtrace {
+ let mut bt = Self::create(Self::new as usize);
+ bt.resolve();
+ bt
+ }
+
+ /// Similar to `new` except that this does not resolve any symbols, this
+ /// simply captures the backtrace as a list of addresses.
+ ///
+ /// At a later time the `resolve` function can be called to resolve this
+ /// backtrace's symbols into readable names. This function exists because
+ /// the resolution process can sometimes take a significant amount of time
+ /// whereas any one backtrace may only be rarely printed.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// use backtrace::Backtrace;
+ ///
+ /// let mut current_backtrace = Backtrace::new_unresolved();
+ /// println!("{:?}", current_backtrace); // no symbol names
+ /// current_backtrace.resolve();
+ /// println!("{:?}", current_backtrace); // symbol names now present
+ /// ```
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ #[inline(never)] // want to make sure there's a frame here to remove
+ pub fn new_unresolved() -> Backtrace {
+ Self::create(Self::new_unresolved as usize)
+ }
+
+ fn create(ip: usize) -> Backtrace {
+ let mut frames = Vec::new();
+ let mut actual_start_index = None;
+ trace(|frame| {
+ frames.push(BacktraceFrame {
+ frame: Frame::Raw(frame.clone()),
+ symbols: None,
+ });
+
+ if frame.symbol_address() as usize == ip && actual_start_index.is_none() {
+ actual_start_index = Some(frames.len());
+ }
+ true
+ });
+
+ Backtrace {
+ frames,
+ actual_start_index: actual_start_index.unwrap_or(0),
+ }
+ }
+
+ /// Returns the frames from when this backtrace was captured.
+ ///
+ /// The first entry of this slice is likely the function `Backtrace::new`,
+ /// and the last frame is likely something about how this thread or the main
+ /// function started.
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn frames(&self) -> &[BacktraceFrame] {
+ &self.frames[self.actual_start_index..]
+ }
+
+ /// If this backtrace was created from `new_unresolved` then this function
+ /// will resolve all addresses in the backtrace to their symbolic names.
+ ///
+ /// If this backtrace has been previously resolved or was created through
+ /// `new`, this function does nothing.
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn resolve(&mut self) {
+ for frame in self.frames.iter_mut().filter(|f| f.symbols.is_none()) {
+ let mut symbols = Vec::new();
+ {
+ let sym = |symbol: &Symbol| {
+ symbols.push(BacktraceSymbol {
+ name: symbol.name().map(|m| m.as_bytes().to_vec()),
+ addr: symbol.addr().map(|a| a as usize),
+ filename: symbol.filename().map(|m| m.to_owned()),
+ lineno: symbol.lineno(),
+ colno: symbol.colno(),
+ });
+ };
+ match frame.frame {
+ Frame::Raw(ref f) => resolve_frame(f, sym),
+ Frame::Deserialized { ip, .. } => {
+ resolve(ip as *mut c_void, sym);
+ }
+ }
+ }
+ frame.symbols = Some(symbols);
+ }
+ }
+}
+
+impl From<Vec<BacktraceFrame>> for Backtrace {
+ fn from(frames: Vec<BacktraceFrame>) -> Self {
+ Backtrace {
+ frames,
+ actual_start_index: 0,
+ }
+ }
+}
+
+impl From<crate::Frame> for BacktraceFrame {
+ fn from(frame: crate::Frame) -> BacktraceFrame {
+ BacktraceFrame {
+ frame: Frame::Raw(frame),
+ symbols: None,
+ }
+ }
+}
+
+impl Into<Vec<BacktraceFrame>> for Backtrace {
+ fn into(self) -> Vec<BacktraceFrame> {
+ self.frames
+ }
+}
+
+impl BacktraceFrame {
+ /// Same as `Frame::ip`
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn ip(&self) -> *mut c_void {
+ self.frame.ip() as *mut c_void
+ }
+
+ /// Same as `Frame::symbol_address`
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn symbol_address(&self) -> *mut c_void {
+ self.frame.symbol_address() as *mut c_void
+ }
+
+ /// Same as `Frame::module_base_address`
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn module_base_address(&self) -> Option<*mut c_void> {
+ self.frame
+ .module_base_address()
+ .map(|addr| addr as *mut c_void)
+ }
+
+ /// Returns the list of symbols that this frame corresponds to.
+ ///
+ /// Normally there is only one symbol per frame, but sometimes if a number
+ /// of functions are inlined into one frame then multiple symbols will be
+ /// returned. The first symbol listed is the "innermost function", whereas
+ /// the last symbol is the outermost (last caller).
+ ///
+ /// Note that if this frame came from an unresolved backtrace then this will
+ /// return an empty list.
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn symbols(&self) -> &[BacktraceSymbol] {
+ self.symbols.as_ref().map(|s| &s[..]).unwrap_or(&[])
+ }
+}
+
+impl BacktraceSymbol {
+ /// Same as `Symbol::name`
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn name(&self) -> Option<SymbolName<'_>> {
+ self.name.as_ref().map(|s| SymbolName::new(s))
+ }
+
+ /// Same as `Symbol::addr`
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn addr(&self) -> Option<*mut c_void> {
+ self.addr.map(|s| s as *mut c_void)
+ }
+
+ /// Same as `Symbol::filename`
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn filename(&self) -> Option<&Path> {
+ self.filename.as_ref().map(|p| &**p)
+ }
+
+ /// Same as `Symbol::lineno`
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn lineno(&self) -> Option<u32> {
+ self.lineno
+ }
+
+ /// Same as `Symbol::colno`
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn colno(&self) -> Option<u32> {
+ self.colno
+ }
+}
+
+impl fmt::Debug for Backtrace {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let full = fmt.alternate();
+ let (frames, style) = if full {
+ (&self.frames[..], PrintFmt::Full)
+ } else {
+ (&self.frames[self.actual_start_index..], PrintFmt::Short)
+ };
+
+ // When printing paths we try to strip the cwd if it exists, otherwise
+ // we just print the path as-is. Note that we also only do this for the
+ // short format, because if it's full we presumably want to print
+ // everything.
+ let cwd = std::env::current_dir();
+ let mut print_path =
+ move |fmt: &mut fmt::Formatter<'_>, path: crate::BytesOrWideString<'_>| {
+ let path = path.into_path_buf();
+ if !full {
+ if let Ok(cwd) = &cwd {
+ if let Ok(suffix) = path.strip_prefix(cwd) {
+ return fmt::Display::fmt(&suffix.display(), fmt);
+ }
+ }
+ }
+ fmt::Display::fmt(&path.display(), fmt)
+ };
+
+ let mut f = BacktraceFmt::new(fmt, style, &mut print_path);
+ f.add_context()?;
+ for frame in frames {
+ f.frame().backtrace_frame(frame)?;
+ }
+ f.finish()?;
+ Ok(())
+ }
+}
+
+impl Default for Backtrace {
+ fn default() -> Backtrace {
+ Backtrace::new()
+ }
+}
+
+impl fmt::Debug for BacktraceFrame {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt.debug_struct("BacktraceFrame")
+ .field("ip", &self.ip())
+ .field("symbol_address", &self.symbol_address())
+ .finish()
+ }
+}
+
+impl fmt::Debug for BacktraceSymbol {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ fmt.debug_struct("BacktraceSymbol")
+ .field("name", &self.name())
+ .field("addr", &self.addr())
+ .field("filename", &self.filename())
+ .field("lineno", &self.lineno())
+ .field("colno", &self.colno())
+ .finish()
+ }
+}
+
+#[cfg(feature = "serialize-rustc")]
+mod rustc_serialize_impls {
+ use super::*;
+ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+
+ #[derive(RustcEncodable, RustcDecodable)]
+ struct SerializedFrame {
+ ip: usize,
+ symbol_address: usize,
+ module_base_address: Option<usize>,
+ symbols: Option<Vec<BacktraceSymbol>>,
+ }
+
+ impl Decodable for BacktraceFrame {
+ fn decode<D>(d: &mut D) -> Result<Self, D::Error>
+ where
+ D: Decoder,
+ {
+ let frame: SerializedFrame = SerializedFrame::decode(d)?;
+ Ok(BacktraceFrame {
+ frame: Frame::Deserialized {
+ ip: frame.ip,
+ symbol_address: frame.symbol_address,
+ module_base_address: frame.module_base_address,
+ },
+ symbols: frame.symbols,
+ })
+ }
+ }
+
+ impl Encodable for BacktraceFrame {
+ fn encode<E>(&self, e: &mut E) -> Result<(), E::Error>
+ where
+ E: Encoder,
+ {
+ let BacktraceFrame { frame, symbols } = self;
+ SerializedFrame {
+ ip: frame.ip() as usize,
+ symbol_address: frame.symbol_address() as usize,
+ module_base_address: frame.module_base_address().map(|addr| addr as usize),
+ symbols: symbols.clone(),
+ }
+ .encode(e)
+ }
+ }
+}
+
+#[cfg(feature = "serde")]
+mod serde_impls {
+ use super::*;
+ use serde::de::Deserializer;
+ use serde::ser::Serializer;
+ use serde::{Deserialize, Serialize};
+
+ #[derive(Serialize, Deserialize)]
+ struct SerializedFrame {
+ ip: usize,
+ symbol_address: usize,
+ module_base_address: Option<usize>,
+ symbols: Option<Vec<BacktraceSymbol>>,
+ }
+
+ impl Serialize for BacktraceFrame {
+ fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ let BacktraceFrame { frame, symbols } = self;
+ SerializedFrame {
+ ip: frame.ip() as usize,
+ symbol_address: frame.symbol_address() as usize,
+ module_base_address: frame.module_base_address().map(|addr| addr as usize),
+ symbols: symbols.clone(),
+ }
+ .serialize(s)
+ }
+ }
+
+ impl<'a> Deserialize<'a> for BacktraceFrame {
+ fn deserialize<D>(d: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'a>,
+ {
+ let frame: SerializedFrame = SerializedFrame::deserialize(d)?;
+ Ok(BacktraceFrame {
+ frame: Frame::Deserialized {
+ ip: frame.ip,
+ symbol_address: frame.symbol_address,
+ module_base_address: frame.module_base_address,
+ },
+ symbols: frame.symbols,
+ })
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_frame_conversion() {
+ let mut frames = vec![];
+ crate::trace(|frame| {
+ let converted = BacktraceFrame::from(frame.clone());
+ frames.push(converted);
+ true
+ });
+
+ let mut manual = Backtrace::from(frames);
+ manual.resolve();
+ let frames = manual.frames();
+
+ for frame in frames {
+ println!("{:?}", frame.ip());
+ println!("{:?}", frame.symbol_address());
+ println!("{:?}", frame.module_base_address());
+ println!("{:?}", frame.symbols());
+ }
+ }
+}
diff --git a/vendor/backtrace/src/dbghelp.rs b/vendor/backtrace/src/dbghelp.rs
new file mode 100644
index 000000000..e01002beb
--- /dev/null
+++ b/vendor/backtrace/src/dbghelp.rs
@@ -0,0 +1,351 @@
+//! A module to assist in managing dbghelp bindings on Windows
+//!
+//! Backtraces on Windows (at least for MSVC) are largely powered through
+//! `dbghelp.dll` and the various functions that it contains. These functions
+//! are currently loaded *dynamically* rather than linking to `dbghelp.dll`
+//! statically. This is currently done by the standard library (and is in theory
+//! required there), but is an effort to help reduce the static dll dependencies
+//! of a library since backtraces are typically pretty optional. That being
+//! said, `dbghelp.dll` almost always successfully loads on Windows.
+//!
+//! Note though that since we're loading all this support dynamically we can't
+//! actually use the raw definitions in `winapi`, but rather we need to define
+//! the function pointer types ourselves and use that. We don't really want to
+//! be in the business of duplicating winapi, so we have a Cargo feature
+//! `verify-winapi` which asserts that all bindings match those in winapi and
+//! this feature is enabled on CI.
+//!
+//! Finally, you'll note here that the dll for `dbghelp.dll` is never unloaded,
+//! and that's currently intentional. The thinking is that we can globally cache
+//! it and use it between calls to the API, avoiding expensive loads/unloads. If
+//! this is a problem for leak detectors or something like that we can cross the
+//! bridge when we get there.
+
+#![allow(non_snake_case)]
+
+use super::windows::*;
+use core::mem;
+use core::ptr;
+
+// Work around `SymGetOptions` and `SymSetOptions` not being present in winapi
+// itself. Otherwise this is only used when we're double-checking types against
+// winapi.
+#[cfg(feature = "verify-winapi")]
+mod dbghelp {
+ use crate::windows::*;
+ pub use winapi::um::dbghelp::{
+ StackWalk64, StackWalkEx, SymCleanup, SymFromAddrW, SymFunctionTableAccess64,
+ SymGetLineFromAddrW64, SymGetModuleBase64, SymGetOptions, SymInitializeW, SymSetOptions,
+ };
+
+ extern "system" {
+ // Not defined in winapi yet
+ pub fn SymFromInlineContextW(
+ hProcess: HANDLE,
+ Address: DWORD64,
+ InlineContext: ULONG,
+ Displacement: PDWORD64,
+ Symbol: PSYMBOL_INFOW,
+ ) -> BOOL;
+ pub fn SymGetLineFromInlineContextW(
+ hProcess: HANDLE,
+ dwAddr: DWORD64,
+ InlineContext: ULONG,
+ qwModuleBaseAddress: DWORD64,
+ pdwDisplacement: PDWORD,
+ Line: PIMAGEHLP_LINEW64,
+ ) -> BOOL;
+ }
+
+ pub fn assert_equal_types<T>(a: T, _b: T) -> T {
+ a
+ }
+}
+
+// This macro is used to define a `Dbghelp` structure which internally contains
+// all the function pointers that we might load.
+macro_rules! dbghelp {
+ (extern "system" {
+ $(fn $name:ident($($arg:ident: $argty:ty),*) -> $ret: ty;)*
+ }) => (
+ pub struct Dbghelp {
+ /// The loaded DLL for `dbghelp.dll`
+ dll: HMODULE,
+
+ // Each function pointer for each function we might use
+ $($name: usize,)*
+ }
+
+ static mut DBGHELP: Dbghelp = Dbghelp {
+ // Initially we haven't loaded the DLL
+ dll: 0 as *mut _,
+ // Initiall all functions are set to zero to say they need to be
+ // dynamically loaded.
+ $($name: 0,)*
+ };
+
+ // Convenience typedef for each function type.
+ $(pub type $name = unsafe extern "system" fn($($argty),*) -> $ret;)*
+
+ impl Dbghelp {
+ /// Attempts to open `dbghelp.dll`. Returns success if it works or
+ /// error if `LoadLibraryW` fails.
+ ///
+ /// Panics if library is already loaded.
+ fn ensure_open(&mut self) -> Result<(), ()> {
+ if !self.dll.is_null() {
+ return Ok(())
+ }
+ let lib = b"dbghelp.dll\0";
+ unsafe {
+ self.dll = LoadLibraryA(lib.as_ptr() as *const i8);
+ if self.dll.is_null() {
+ Err(())
+ } else {
+ Ok(())
+ }
+ }
+ }
+
+ // Function for each method we'd like to use. When called it will
+ // either read the cached function pointer or load it and return the
+ // loaded value. Loads are asserted to succeed.
+ $(pub fn $name(&mut self) -> Option<$name> {
+ unsafe {
+ if self.$name == 0 {
+ let name = concat!(stringify!($name), "\0");
+ self.$name = self.symbol(name.as_bytes())?;
+ }
+ let ret = mem::transmute::<usize, $name>(self.$name);
+ #[cfg(feature = "verify-winapi")]
+ dbghelp::assert_equal_types(ret, dbghelp::$name);
+ Some(ret)
+ }
+ })*
+
+ fn symbol(&self, symbol: &[u8]) -> Option<usize> {
+ unsafe {
+ match GetProcAddress(self.dll, symbol.as_ptr() as *const _) as usize {
+ 0 => None,
+ n => Some(n),
+ }
+ }
+ }
+ }
+
+ // Convenience proxy to use the cleanup locks to reference dbghelp
+ // functions.
+ #[allow(dead_code)]
+ impl Init {
+ $(pub fn $name(&self) -> $name {
+ unsafe {
+ DBGHELP.$name().unwrap()
+ }
+ })*
+
+ pub fn dbghelp(&self) -> *mut Dbghelp {
+ unsafe {
+ &mut DBGHELP
+ }
+ }
+ }
+ )
+
+}
+
+const SYMOPT_DEFERRED_LOADS: DWORD = 0x00000004;
+
+dbghelp! {
+ extern "system" {
+ fn SymGetOptions() -> DWORD;
+ fn SymSetOptions(options: DWORD) -> DWORD;
+ fn SymInitializeW(
+ handle: HANDLE,
+ path: PCWSTR,
+ invade: BOOL
+ ) -> BOOL;
+ fn SymCleanup(handle: HANDLE) -> BOOL;
+ fn StackWalk64(
+ MachineType: DWORD,
+ hProcess: HANDLE,
+ hThread: HANDLE,
+ StackFrame: LPSTACKFRAME64,
+ ContextRecord: PVOID,
+ ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64,
+ FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64,
+ GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64,
+ TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64
+ ) -> BOOL;
+ fn SymFunctionTableAccess64(
+ hProcess: HANDLE,
+ AddrBase: DWORD64
+ ) -> PVOID;
+ fn SymGetModuleBase64(
+ hProcess: HANDLE,
+ AddrBase: DWORD64
+ ) -> DWORD64;
+ fn SymFromAddrW(
+ hProcess: HANDLE,
+ Address: DWORD64,
+ Displacement: PDWORD64,
+ Symbol: PSYMBOL_INFOW
+ ) -> BOOL;
+ fn SymGetLineFromAddrW64(
+ hProcess: HANDLE,
+ dwAddr: DWORD64,
+ pdwDisplacement: PDWORD,
+ Line: PIMAGEHLP_LINEW64
+ ) -> BOOL;
+ fn StackWalkEx(
+ MachineType: DWORD,
+ hProcess: HANDLE,
+ hThread: HANDLE,
+ StackFrame: LPSTACKFRAME_EX,
+ ContextRecord: PVOID,
+ ReadMemoryRoutine: PREAD_PROCESS_MEMORY_ROUTINE64,
+ FunctionTableAccessRoutine: PFUNCTION_TABLE_ACCESS_ROUTINE64,
+ GetModuleBaseRoutine: PGET_MODULE_BASE_ROUTINE64,
+ TranslateAddress: PTRANSLATE_ADDRESS_ROUTINE64,
+ Flags: DWORD
+ ) -> BOOL;
+ fn SymFromInlineContextW(
+ hProcess: HANDLE,
+ Address: DWORD64,
+ InlineContext: ULONG,
+ Displacement: PDWORD64,
+ Symbol: PSYMBOL_INFOW
+ ) -> BOOL;
+ fn SymGetLineFromInlineContextW(
+ hProcess: HANDLE,
+ dwAddr: DWORD64,
+ InlineContext: ULONG,
+ qwModuleBaseAddress: DWORD64,
+ pdwDisplacement: PDWORD,
+ Line: PIMAGEHLP_LINEW64
+ ) -> BOOL;
+ }
+}
+
+pub struct Init {
+ lock: HANDLE,
+}
+
+/// Initialize all support necessary to access `dbghelp` API functions from this
+/// crate.
+///
+/// Note that this function is **safe**, it internally has its own
+/// synchronization. Also note that it is safe to call this function multiple
+/// times recursively.
+pub fn init() -> Result<Init, ()> {
+ use core::sync::atomic::{AtomicUsize, Ordering::SeqCst};
+
+ unsafe {
+ // First thing we need to do is to synchronize this function. This can
+ // be called concurrently from other threads or recursively within one
+ // thread. Note that it's trickier than that though because what we're
+ // using here, `dbghelp`, *also* needs to be synchronized with all other
+ // callers to `dbghelp` in this process.
+ //
+ // Typically there aren't really that many calls to `dbghelp` within the
+ // same process and we can probably safely assume that we're the only
+ // ones accessing it. There is, however, one primary other user we have
+ // to worry about which is ironically ourselves, but in the standard
+ // library. The Rust standard library depends on this crate for
+ // backtrace support, and this crate also exists on crates.io. This
+ // means that if the standard library is printing a panic backtrace it
+ // may race with this crate coming from crates.io, causing segfaults.
+ //
+ // To help solve this synchronization problem we employ a
+ // Windows-specific trick here (it is, after all, a Windows-specific
+ // restriction about synchronization). We create a *session-local* named
+ // mutex to protect this call. The intention here is that the standard
+ // library and this crate don't have to share Rust-level APIs to
+ // synchronize here but can instead work behind the scenes to make sure
+ // they're synchronizing with one another. That way when this function
+ // is called through the standard library or through crates.io we can be
+ // sure that the same mutex is being acquired.
+ //
+ // So all of that is to say that the first thing we do here is we
+ // atomically create a `HANDLE` which is a named mutex on Windows. We
+ // synchronize a bit with other threads sharing this function
+ // specifically and ensure that only one handle is created per instance
+ // of this function. Note that the handle is never closed once it's
+ // stored in the global.
+ //
+ // After we've actually go the lock we simply acquire it, and our `Init`
+ // handle we hand out will be responsible for dropping it eventually.
+ static LOCK: AtomicUsize = AtomicUsize::new(0);
+ let mut lock = LOCK.load(SeqCst);
+ if lock == 0 {
+ lock = CreateMutexA(
+ ptr::null_mut(),
+ 0,
+ "Local\\RustBacktraceMutex\0".as_ptr() as _,
+ ) as usize;
+ if lock == 0 {
+ return Err(());
+ }
+ if let Err(other) = LOCK.compare_exchange(0, lock, SeqCst, SeqCst) {
+ debug_assert!(other != 0);
+ CloseHandle(lock as HANDLE);
+ lock = other;
+ }
+ }
+ debug_assert!(lock != 0);
+ let lock = lock as HANDLE;
+ let r = WaitForSingleObjectEx(lock, INFINITE, FALSE);
+ debug_assert_eq!(r, 0);
+ let ret = Init { lock };
+
+ // Ok, phew! Now that we're all safely synchronized, let's actually
+ // start processing everything. First up we need to ensure that
+ // `dbghelp.dll` is actually loaded in this process. We do this
+ // dynamically to avoid a static dependency. This has historically been
+ // done to work around weird linking issues and is intended at making
+ // binaries a bit more portable since this is largely just a debugging
+ // utility.
+ //
+ // Once we've opened `dbghelp.dll` we need to call some initialization
+ // functions in it, and that's detailed more below. We only do this
+ // once, though, so we've got a global boolean indicating whether we're
+ // done yet or not.
+ DBGHELP.ensure_open()?;
+
+ static mut INITIALIZED: bool = false;
+ if INITIALIZED {
+ return Ok(ret);
+ }
+
+ let orig = DBGHELP.SymGetOptions().unwrap()();
+
+ // Ensure that the `SYMOPT_DEFERRED_LOADS` flag is set, because
+ // according to MSVC's own docs about this: "This is the fastest, most
+ // efficient way to use the symbol handler.", so let's do that!
+ DBGHELP.SymSetOptions().unwrap()(orig | SYMOPT_DEFERRED_LOADS);
+
+ // Actually initialize symbols with MSVC. Note that this can fail, but we
+ // ignore it. There's not a ton of prior art for this per se, but LLVM
+ // internally seems to ignore the return value here and one of the
+ // sanitizer libraries in LLVM prints a scary warning if this fails but
+ // basically ignores it in the long run.
+ //
+ // One case this comes up a lot for Rust is that the standard library and
+ // this crate on crates.io both want to compete for `SymInitializeW`. The
+ // standard library historically wanted to initialize then cleanup most of
+ // the time, but now that it's using this crate it means that someone will
+ // get to initialization first and the other will pick up that
+ // initialization.
+ DBGHELP.SymInitializeW().unwrap()(GetCurrentProcess(), ptr::null_mut(), TRUE);
+ INITIALIZED = true;
+ Ok(ret)
+ }
+}
+
+impl Drop for Init {
+ fn drop(&mut self) {
+ unsafe {
+ let r = ReleaseMutex(self.lock);
+ debug_assert!(r != 0);
+ }
+ }
+}
diff --git a/vendor/backtrace/src/lib.rs b/vendor/backtrace/src/lib.rs
new file mode 100644
index 000000000..e5dea3387
--- /dev/null
+++ b/vendor/backtrace/src/lib.rs
@@ -0,0 +1,193 @@
+//! A library for acquiring a backtrace at runtime
+//!
+//! This library is meant to supplement the `RUST_BACKTRACE=1` support of the
+//! standard library by allowing an acquisition of a backtrace at runtime
+//! programmatically. The backtraces generated by this library do not need to be
+//! parsed, for example, and expose the functionality of multiple backend
+//! implementations.
+//!
+//! # Usage
+//!
+//! First, add this to your Cargo.toml
+//!
+//! ```toml
+//! [dependencies]
+//! backtrace = "0.3"
+//! ```
+//!
+//! Next:
+//!
+//! ```
+//! fn main() {
+//! # // Unsafe here so test passes on no_std.
+//! # #[cfg(feature = "std")] {
+//! backtrace::trace(|frame| {
+//! let ip = frame.ip();
+//! let symbol_address = frame.symbol_address();
+//!
+//! // Resolve this instruction pointer to a symbol name
+//! backtrace::resolve_frame(frame, |symbol| {
+//! if let Some(name) = symbol.name() {
+//! // ...
+//! }
+//! if let Some(filename) = symbol.filename() {
+//! // ...
+//! }
+//! });
+//!
+//! true // keep going to the next frame
+//! });
+//! }
+//! # }
+//! ```
+//!
+//! # Backtrace accuracy
+//!
+//! This crate implements best-effort attempts to get the native backtrace. This
+//! is not always guaranteed to work, and some platforms don't return any
+//! backtrace at all. If your application requires accurate backtraces then it's
+//! recommended to closely evaluate this crate to see whether it's suitable
+//! for your use case on your target platforms.
+//!
+//! Even on supported platforms, there's a number of reasons that backtraces may
+//! be less-than-accurate, including but not limited to:
+//!
+//! * Unwind information may not be available. This crate primarily implements
+//! backtraces by unwinding the stack, but not all functions may have
+//! unwinding information (e.g. DWARF unwinding information).
+//!
+//! * Rust code may be compiled without unwinding information for some
+//! functions. This can also happen for Rust code compiled with
+//! `-Cpanic=abort`. You can remedy this, however, with
+//! `-Cforce-unwind-tables` as a compiler option.
+//!
+//! * Unwind information may be inaccurate or corrupt. In the worst case
+//! inaccurate unwind information can lead this library to segfault. In the
+//! best case inaccurate information will result in a truncated stack trace.
+//!
+//! * Backtraces may not report filenames/line numbers correctly due to missing
+//! or corrupt debug information. This won't lead to segfaults unlike corrupt
+//! unwinding information, but missing or malformed debug information will
+//! mean that filenames and line numbers will not be available. This may be
+//! because debug information wasn't generated by the compiler, or it's just
+//! missing on the filesystem.
+//!
+//! * Not all platforms are supported. For example there's no way to get a
+//! backtrace on WebAssembly at the moment.
+//!
+//! * Crate features may be disabled. Currently this crate supports using Gimli
+//! libbacktrace on non-Windows platforms for reading debuginfo for
+//! backtraces. If both crate features are disabled, however, then these
+//! platforms will generate a backtrace but be unable to generate symbols for
+//! it.
+//!
+//! In most standard workflows for most standard platforms you generally don't
+//! need to worry about these caveats. We'll try to fix ones where we can over
+//! time, but otherwise it's important to be aware of the limitations of
+//! unwinding-based backtraces!
+
+#![doc(html_root_url = "https://docs.rs/backtrace")]
+#![deny(missing_docs)]
+#![no_std]
+#![cfg_attr(
+ all(feature = "std", target_env = "sgx", target_vendor = "fortanix"),
+ feature(sgx_platform)
+)]
+#![warn(rust_2018_idioms)]
+// When we're building as part of libstd, silence all warnings since they're
+// irrelevant as this crate is developed out-of-tree.
+#![cfg_attr(backtrace_in_libstd, allow(warnings))]
+#![cfg_attr(not(feature = "std"), allow(dead_code))]
+// We know this is deprecated, it's only here for back-compat reasons.
+#![cfg_attr(feature = "rustc-serialize", allow(deprecated))]
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate std;
+
+// This is only used for gimli right now, which is only used on some platforms, and miri
+// so don't worry if it's unused in other configurations.
+#[allow(unused_extern_crates)]
+extern crate alloc;
+
+pub use self::backtrace::{trace_unsynchronized, Frame};
+mod backtrace;
+
+pub use self::symbolize::resolve_frame_unsynchronized;
+pub use self::symbolize::{resolve_unsynchronized, Symbol, SymbolName};
+mod symbolize;
+
+pub use self::types::BytesOrWideString;
+mod types;
+
+#[cfg(feature = "std")]
+pub use self::symbolize::clear_symbol_cache;
+
+mod print;
+pub use print::{BacktraceFmt, BacktraceFrameFmt, PrintFmt};
+
+cfg_if::cfg_if! {
+ if #[cfg(feature = "std")] {
+ pub use self::backtrace::trace;
+ pub use self::symbolize::{resolve, resolve_frame};
+ pub use self::capture::{Backtrace, BacktraceFrame, BacktraceSymbol};
+ mod capture;
+ }
+}
+
+#[allow(dead_code)]
+struct Bomb {
+ enabled: bool,
+}
+
+#[allow(dead_code)]
+impl Drop for Bomb {
+ fn drop(&mut self) {
+ if self.enabled {
+ panic!("cannot panic during the backtrace function");
+ }
+ }
+}
+
+#[allow(dead_code)]
+#[cfg(feature = "std")]
+mod lock {
+ use std::boxed::Box;
+ use std::cell::Cell;
+ use std::sync::{Mutex, MutexGuard, Once};
+
+ pub struct LockGuard(Option<MutexGuard<'static, ()>>);
+
+ static mut LOCK: *mut Mutex<()> = 0 as *mut _;
+ static INIT: Once = Once::new();
+ thread_local!(static LOCK_HELD: Cell<bool> = Cell::new(false));
+
+ impl Drop for LockGuard {
+ fn drop(&mut self) {
+ if self.0.is_some() {
+ LOCK_HELD.with(|slot| {
+ assert!(slot.get());
+ slot.set(false);
+ });
+ }
+ }
+ }
+
+ pub fn lock() -> LockGuard {
+ if LOCK_HELD.with(|l| l.get()) {
+ return LockGuard(None);
+ }
+ LOCK_HELD.with(|s| s.set(true));
+ unsafe {
+ INIT.call_once(|| {
+ LOCK = Box::into_raw(Box::new(Mutex::new(())));
+ });
+ LockGuard(Some((*LOCK).lock().unwrap()))
+ }
+ }
+}
+
+#[cfg(all(windows, not(target_vendor = "uwp")))]
+mod dbghelp;
+#[cfg(windows)]
+mod windows;
diff --git a/vendor/backtrace/src/print.rs b/vendor/backtrace/src/print.rs
new file mode 100644
index 000000000..cc677122a
--- /dev/null
+++ b/vendor/backtrace/src/print.rs
@@ -0,0 +1,302 @@
+#[cfg(feature = "std")]
+use super::{BacktraceFrame, BacktraceSymbol};
+use super::{BytesOrWideString, Frame, SymbolName};
+use core::ffi::c_void;
+use core::fmt;
+
+const HEX_WIDTH: usize = 2 + 2 * core::mem::size_of::<usize>();
+
+#[cfg(target_os = "fuchsia")]
+mod fuchsia;
+
+/// A formatter for backtraces.
+///
+/// This type can be used to print a backtrace regardless of where the backtrace
+/// itself comes from. If you have a `Backtrace` type then its `Debug`
+/// implementation already uses this printing format.
+pub struct BacktraceFmt<'a, 'b> {
+ fmt: &'a mut fmt::Formatter<'b>,
+ frame_index: usize,
+ format: PrintFmt,
+ print_path:
+ &'a mut (dyn FnMut(&mut fmt::Formatter<'_>, BytesOrWideString<'_>) -> fmt::Result + 'b),
+}
+
+/// The styles of printing that we can print
+#[derive(Copy, Clone, Eq, PartialEq)]
+pub enum PrintFmt {
+ /// Prints a terser backtrace which ideally only contains relevant information
+ Short,
+ /// Prints a backtrace that contains all possible information
+ Full,
+ #[doc(hidden)]
+ __Nonexhaustive,
+}
+
+impl<'a, 'b> BacktraceFmt<'a, 'b> {
+ /// Create a new `BacktraceFmt` which will write output to the provided
+ /// `fmt`.
+ ///
+ /// The `format` argument will control the style in which the backtrace is
+ /// printed, and the `print_path` argument will be used to print the
+ /// `BytesOrWideString` instances of filenames. This type itself doesn't do
+ /// any printing of filenames, but this callback is required to do so.
+ pub fn new(
+ fmt: &'a mut fmt::Formatter<'b>,
+ format: PrintFmt,
+ print_path: &'a mut (dyn FnMut(&mut fmt::Formatter<'_>, BytesOrWideString<'_>) -> fmt::Result
+ + 'b),
+ ) -> Self {
+ BacktraceFmt {
+ fmt,
+ frame_index: 0,
+ format,
+ print_path,
+ }
+ }
+
+ /// Prints a preamble for the backtrace about to be printed.
+ ///
+ /// This is required on some platforms for backtraces to be fully
+ /// symbolicated later, and otherwise this should just be the first method
+ /// you call after creating a `BacktraceFmt`.
+ pub fn add_context(&mut self) -> fmt::Result {
+ #[cfg(target_os = "fuchsia")]
+ fuchsia::print_dso_context(self.fmt)?;
+ Ok(())
+ }
+
+ /// Adds a frame to the backtrace output.
+ ///
+ /// This commit returns an RAII instance of a `BacktraceFrameFmt` which can be used
+ /// to actually print a frame, and on destruction it will increment the
+ /// frame counter.
+ pub fn frame(&mut self) -> BacktraceFrameFmt<'_, 'a, 'b> {
+ BacktraceFrameFmt {
+ fmt: self,
+ symbol_index: 0,
+ }
+ }
+
+ /// Completes the backtrace output.
+ ///
+ /// This is currently a no-op but is added for future compatibility with
+ /// backtrace formats.
+ pub fn finish(&mut self) -> fmt::Result {
+ // Currently a no-op-- including this hook to allow for future additions.
+ Ok(())
+ }
+}
+
+/// A formatter for just one frame of a backtrace.
+///
+/// This type is created by the `BacktraceFmt::frame` function.
+pub struct BacktraceFrameFmt<'fmt, 'a, 'b> {
+ fmt: &'fmt mut BacktraceFmt<'a, 'b>,
+ symbol_index: usize,
+}
+
+impl BacktraceFrameFmt<'_, '_, '_> {
+ /// Prints a `BacktraceFrame` with this frame formatter.
+ ///
+ /// This will recursively print all `BacktraceSymbol` instances within the
+ /// `BacktraceFrame`.
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ #[cfg(feature = "std")]
+ pub fn backtrace_frame(&mut self, frame: &BacktraceFrame) -> fmt::Result {
+ let symbols = frame.symbols();
+ for symbol in symbols {
+ self.backtrace_symbol(frame, symbol)?;
+ }
+ if symbols.is_empty() {
+ self.print_raw(frame.ip(), None, None, None)?;
+ }
+ Ok(())
+ }
+
+ /// Prints a `BacktraceSymbol` within a `BacktraceFrame`.
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ #[cfg(feature = "std")]
+ pub fn backtrace_symbol(
+ &mut self,
+ frame: &BacktraceFrame,
+ symbol: &BacktraceSymbol,
+ ) -> fmt::Result {
+ self.print_raw_with_column(
+ frame.ip(),
+ symbol.name(),
+ // TODO: this isn't great that we don't end up printing anything
+ // with non-utf8 filenames. Thankfully almost everything is utf8 so
+ // this shouldn't be too too bad.
+ symbol
+ .filename()
+ .and_then(|p| Some(BytesOrWideString::Bytes(p.to_str()?.as_bytes()))),
+ symbol.lineno(),
+ symbol.colno(),
+ )?;
+ Ok(())
+ }
+
+ /// Prints a raw traced `Frame` and `Symbol`, typically from within the raw
+ /// callbacks of this crate.
+ pub fn symbol(&mut self, frame: &Frame, symbol: &super::Symbol) -> fmt::Result {
+ self.print_raw_with_column(
+ frame.ip(),
+ symbol.name(),
+ symbol.filename_raw(),
+ symbol.lineno(),
+ symbol.colno(),
+ )?;
+ Ok(())
+ }
+
+ /// Adds a raw frame to the backtrace output.
+ ///
+ /// This method, unlike the previous, takes the raw arguments in case
+ /// they're being source from different locations. Note that this may be
+ /// called multiple times for one frame.
+ pub fn print_raw(
+ &mut self,
+ frame_ip: *mut c_void,
+ symbol_name: Option<SymbolName<'_>>,
+ filename: Option<BytesOrWideString<'_>>,
+ lineno: Option<u32>,
+ ) -> fmt::Result {
+ self.print_raw_with_column(frame_ip, symbol_name, filename, lineno, None)
+ }
+
+ /// Adds a raw frame to the backtrace output, including column information.
+ ///
+ /// This method, like the previous, takes the raw arguments in case
+ /// they're being source from different locations. Note that this may be
+ /// called multiple times for one frame.
+ pub fn print_raw_with_column(
+ &mut self,
+ frame_ip: *mut c_void,
+ symbol_name: Option<SymbolName<'_>>,
+ filename: Option<BytesOrWideString<'_>>,
+ lineno: Option<u32>,
+ colno: Option<u32>,
+ ) -> fmt::Result {
+ // Fuchsia is unable to symbolize within a process so it has a special
+ // format which can be used to symbolize later. Print that instead of
+ // printing addresses in our own format here.
+ if cfg!(target_os = "fuchsia") {
+ self.print_raw_fuchsia(frame_ip)?;
+ } else {
+ self.print_raw_generic(frame_ip, symbol_name, filename, lineno, colno)?;
+ }
+ self.symbol_index += 1;
+ Ok(())
+ }
+
+ #[allow(unused_mut)]
+ fn print_raw_generic(
+ &mut self,
+ mut frame_ip: *mut c_void,
+ symbol_name: Option<SymbolName<'_>>,
+ filename: Option<BytesOrWideString<'_>>,
+ lineno: Option<u32>,
+ colno: Option<u32>,
+ ) -> fmt::Result {
+ // No need to print "null" frames, it basically just means that the
+ // system backtrace was a bit eager to trace back super far.
+ if let PrintFmt::Short = self.fmt.format {
+ if frame_ip.is_null() {
+ return Ok(());
+ }
+ }
+
+ // To reduce TCB size in Sgx enclave, we do not want to implement symbol
+ // resolution functionality. Rather, we can print the offset of the
+ // address here, which could be later mapped to correct function.
+ #[cfg(all(feature = "std", target_env = "sgx", target_vendor = "fortanix"))]
+ {
+ let image_base = std::os::fortanix_sgx::mem::image_base();
+ frame_ip = usize::wrapping_sub(frame_ip as usize, image_base as _) as _;
+ }
+
+ // Print the index of the frame as well as the optional instruction
+ // pointer of the frame. If we're beyond the first symbol of this frame
+ // though we just print appropriate whitespace.
+ if self.symbol_index == 0 {
+ write!(self.fmt.fmt, "{:4}: ", self.fmt.frame_index)?;
+ if let PrintFmt::Full = self.fmt.format {
+ write!(self.fmt.fmt, "{:1$?} - ", frame_ip, HEX_WIDTH)?;
+ }
+ } else {
+ write!(self.fmt.fmt, " ")?;
+ if let PrintFmt::Full = self.fmt.format {
+ write!(self.fmt.fmt, "{:1$}", "", HEX_WIDTH + 3)?;
+ }
+ }
+
+ // Next up write out the symbol name, using the alternate formatting for
+ // more information if we're a full backtrace. Here we also handle
+ // symbols which don't have a name,
+ match (symbol_name, &self.fmt.format) {
+ (Some(name), PrintFmt::Short) => write!(self.fmt.fmt, "{:#}", name)?,
+ (Some(name), PrintFmt::Full) => write!(self.fmt.fmt, "{}", name)?,
+ (None, _) | (_, PrintFmt::__Nonexhaustive) => write!(self.fmt.fmt, "<unknown>")?,
+ }
+ self.fmt.fmt.write_str("\n")?;
+
+ // And last up, print out the filename/line number if they're available.
+ if let (Some(file), Some(line)) = (filename, lineno) {
+ self.print_fileline(file, line, colno)?;
+ }
+
+ Ok(())
+ }
+
+ fn print_fileline(
+ &mut self,
+ file: BytesOrWideString<'_>,
+ line: u32,
+ colno: Option<u32>,
+ ) -> fmt::Result {
+ // Filename/line are printed on lines under the symbol name, so print
+ // some appropriate whitespace to sort of right-align ourselves.
+ if let PrintFmt::Full = self.fmt.format {
+ write!(self.fmt.fmt, "{:1$}", "", HEX_WIDTH)?;
+ }
+ write!(self.fmt.fmt, " at ")?;
+
+ // Delegate to our internal callback to print the filename and then
+ // print out the line number.
+ (self.fmt.print_path)(self.fmt.fmt, file)?;
+ write!(self.fmt.fmt, ":{}", line)?;
+
+ // Add column number, if available.
+ if let Some(colno) = colno {
+ write!(self.fmt.fmt, ":{}", colno)?;
+ }
+
+ write!(self.fmt.fmt, "\n")?;
+ Ok(())
+ }
+
+ fn print_raw_fuchsia(&mut self, frame_ip: *mut c_void) -> fmt::Result {
+ // We only care about the first symbol of a frame
+ if self.symbol_index == 0 {
+ self.fmt.fmt.write_str("{{{bt:")?;
+ write!(self.fmt.fmt, "{}:{:?}", self.fmt.frame_index, frame_ip)?;
+ self.fmt.fmt.write_str("}}}\n")?;
+ }
+ Ok(())
+ }
+}
+
+impl Drop for BacktraceFrameFmt<'_, '_, '_> {
+ fn drop(&mut self) {
+ self.fmt.frame_index += 1;
+ }
+}
diff --git a/vendor/backtrace/src/print/fuchsia.rs b/vendor/backtrace/src/print/fuchsia.rs
new file mode 100644
index 000000000..959253acb
--- /dev/null
+++ b/vendor/backtrace/src/print/fuchsia.rs
@@ -0,0 +1,436 @@
+use core::fmt::{self, Write};
+use core::mem::{size_of, transmute};
+use core::slice::from_raw_parts;
+use libc::c_char;
+
+extern "C" {
+ // dl_iterate_phdr takes a callback that will receive a dl_phdr_info pointer
+ // for every DSO that has been linked into the process. dl_iterate_phdr also
+ // ensures that the dynamic linker is locked from start to finish of the
+ // iteration. If the callback returns a non-zero value the iteration is
+ // terminated early. 'data' will be passed as the third argument to the
+ // callback on each call. 'size' gives the size of the dl_phdr_info.
+ #[allow(improper_ctypes)]
+ fn dl_iterate_phdr(
+ f: extern "C" fn(info: &dl_phdr_info, size: usize, data: &mut DsoPrinter<'_, '_>) -> i32,
+ data: &mut DsoPrinter<'_, '_>,
+ ) -> i32;
+}
+
+// We need to parse out the build ID and some basic program header data
+// which means that we need a bit of stuff from the ELF spec as well.
+
+const PT_LOAD: u32 = 1;
+const PT_NOTE: u32 = 4;
+
+// Now we have to replicate, bit for bit, the structure of the dl_phdr_info
+// type used by fuchsia's current dynamic linker. Chromium also has this ABI
+// boundary as well as crashpad. Eventully we'd like to move these cases to
+// use elf-search but we'd need to provide that in the SDK and that has not
+// yet been done. Thus we (and they) are stuck having to use this method
+// which incurs a tight coupling with the fuchsia libc.
+
+#[allow(non_camel_case_types)]
+#[repr(C)]
+struct dl_phdr_info {
+ addr: *const u8,
+ name: *const c_char,
+ phdr: *const Elf_Phdr,
+ phnum: u16,
+ adds: u64,
+ subs: u64,
+ tls_modid: usize,
+ tls_data: *const u8,
+}
+
+impl dl_phdr_info {
+ fn program_headers(&self) -> PhdrIter<'_> {
+ PhdrIter {
+ phdrs: self.phdr_slice(),
+ base: self.addr,
+ }
+ }
+ // We have no way of knowing of checking if e_phoff and e_phnum are valid.
+ // libc should ensure this for us however so it's safe to form a slice here.
+ fn phdr_slice(&self) -> &[Elf_Phdr] {
+ unsafe { from_raw_parts(self.phdr, self.phnum as usize) }
+ }
+}
+
+struct PhdrIter<'a> {
+ phdrs: &'a [Elf_Phdr],
+ base: *const u8,
+}
+
+impl<'a> Iterator for PhdrIter<'a> {
+ type Item = Phdr<'a>;
+ fn next(&mut self) -> Option<Self::Item> {
+ self.phdrs.split_first().map(|(phdr, new_phdrs)| {
+ self.phdrs = new_phdrs;
+ Phdr {
+ phdr,
+ base: self.base,
+ }
+ })
+ }
+}
+
+// Elf_Phdr represents a 64-bit ELF program header in the endianness of the target
+// architecture.
+#[allow(non_camel_case_types)]
+#[derive(Clone, Debug)]
+#[repr(C)]
+struct Elf_Phdr {
+ p_type: u32,
+ p_flags: u32,
+ p_offset: u64,
+ p_vaddr: u64,
+ p_paddr: u64,
+ p_filesz: u64,
+ p_memsz: u64,
+ p_align: u64,
+}
+
+// Phdr represents a valid ELF program header and its contents.
+struct Phdr<'a> {
+ phdr: &'a Elf_Phdr,
+ base: *const u8,
+}
+
+impl<'a> Phdr<'a> {
+ // We have no way of checking if p_addr or p_memsz are valid. Fuchsia's libc
+ // parses the notes first however so by virtue of being here these headers
+ // must be valid. NoteIter does not require the underlying data to be valid
+ // but it does require the bounds to be valid. We trust that libc has ensured
+ // that this is the case for us here.
+ fn notes(&self) -> NoteIter<'a> {
+ unsafe {
+ NoteIter::new(
+ self.base.add(self.phdr.p_offset as usize),
+ self.phdr.p_memsz as usize,
+ )
+ }
+ }
+}
+
+// The note type for build IDs.
+const NT_GNU_BUILD_ID: u32 = 3;
+
+// Elf_Nhdr represents an ELF note header in the endianness of the target.
+#[allow(non_camel_case_types)]
+#[repr(C)]
+struct Elf_Nhdr {
+ n_namesz: u32,
+ n_descsz: u32,
+ n_type: u32,
+}
+
+// Note represents an ELF note (header + contents). The name is left as a u8
+// slice because it is not always null terminated and rust makes it easy enough
+// to check that the bytes match eitherway.
+struct Note<'a> {
+ name: &'a [u8],
+ desc: &'a [u8],
+ tipe: u32,
+}
+
+// NoteIter lets you safely iterate over a note segment. It terminates as soon
+// as an error occurs or there are no more notes. If you iterate over invalid
+// data it will function as though no notes were found.
+struct NoteIter<'a> {
+ base: &'a [u8],
+ error: bool,
+}
+
+impl<'a> NoteIter<'a> {
+ // It is an invariant of function that the pointer and size given denote a
+ // valid range of bytes that can all be read. The contents of these bytes
+ // can be anything but the range must be valid for this to be safe.
+ unsafe fn new(base: *const u8, size: usize) -> Self {
+ NoteIter {
+ base: from_raw_parts(base, size),
+ error: false,
+ }
+ }
+}
+
+// align_to aligns 'x' to 'to'-byte alignment assuming 'to' is a power of 2.
+// This follows a standard pattern in C/C++ ELF parsing code where
+// (x + to - 1) & -to is used. Rust does not let you negate usize so I use
+// 2's-complement conversion to recreate that.
+fn align_to(x: usize, to: usize) -> usize {
+ (x + to - 1) & (!to + 1)
+}
+
+// take_bytes_align4 consumes num bytes from the slice (if present) and
+// additionally ensures that the final slice is properlly aligned. If an
+// either the number of bytes requested is too large or the slice can't be
+// realigned afterwards due to not enough remaining bytes existing, None is
+// returned and the slice is not modified.
+fn take_bytes_align4<'a>(num: usize, bytes: &mut &'a [u8]) -> Option<&'a [u8]> {
+ if bytes.len() < align_to(num, 4) {
+ return None;
+ }
+ let (out, bytes_new) = bytes.split_at(num);
+ *bytes = &bytes_new[align_to(num, 4) - num..];
+ Some(out)
+}
+
+// This function has no real invariants the caller must uphold other than
+// perhaps that 'bytes' should be aligned for performance (and on some
+// architectures correctness). The values in the Elf_Nhdr fields might
+// be nonsense but this function ensures no such thing.
+fn take_nhdr<'a>(bytes: &mut &'a [u8]) -> Option<&'a Elf_Nhdr> {
+ if size_of::<Elf_Nhdr>() > bytes.len() {
+ return None;
+ }
+ // This is safe as long as there is enough space and we just confirmed that
+ // in the if statement above so this should not be unsafe.
+ let out = unsafe { transmute::<*const u8, &'a Elf_Nhdr>(bytes.as_ptr()) };
+ // Note that sice_of::<Elf_Nhdr>() is always 4-byte aligned.
+ *bytes = &bytes[size_of::<Elf_Nhdr>()..];
+ Some(out)
+}
+
+impl<'a> Iterator for NoteIter<'a> {
+ type Item = Note<'a>;
+ fn next(&mut self) -> Option<Self::Item> {
+ // Check if we've reached the end.
+ if self.base.len() == 0 || self.error {
+ return None;
+ }
+ // We transmute out an nhdr but we carefully consider the resulting
+ // struct. We don't trust the namesz or descsz and we make no unsafe
+ // decisions based on the type. So even if we get out complete garbage
+ // we should still be safe.
+ let nhdr = take_nhdr(&mut self.base)?;
+ let name = take_bytes_align4(nhdr.n_namesz as usize, &mut self.base)?;
+ let desc = take_bytes_align4(nhdr.n_descsz as usize, &mut self.base)?;
+ Some(Note {
+ name: name,
+ desc: desc,
+ tipe: nhdr.n_type,
+ })
+ }
+}
+
+struct Perm(u32);
+
+/// Indicates that a segment is executable.
+const PERM_X: u32 = 0b00000001;
+/// Indicates that a segment is writable.
+const PERM_W: u32 = 0b00000010;
+/// Indicates that a segment is readable.
+const PERM_R: u32 = 0b00000100;
+
+impl core::fmt::Display for Perm {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let v = self.0;
+ if v & PERM_R != 0 {
+ f.write_char('r')?
+ }
+ if v & PERM_W != 0 {
+ f.write_char('w')?
+ }
+ if v & PERM_X != 0 {
+ f.write_char('x')?
+ }
+ Ok(())
+ }
+}
+
+/// Represents an ELF segment at runtime.
+struct Segment {
+ /// Gives the runtime virtual address of this segment's contents.
+ addr: usize,
+ /// Gives the memory size of this segment's contents.
+ size: usize,
+ /// Gives the module virtual address of this segment with the ELF file.
+ mod_rel_addr: usize,
+ /// Gives the permissions found in the ELF file. These permissions are not
+ /// necessarily the permissions present at runtime however.
+ flags: Perm,
+}
+
+/// Lets one iterate over Segments from a DSO.
+struct SegmentIter<'a> {
+ phdrs: &'a [Elf_Phdr],
+ base: usize,
+}
+
+impl Iterator for SegmentIter<'_> {
+ type Item = Segment;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.phdrs.split_first().and_then(|(phdr, new_phdrs)| {
+ self.phdrs = new_phdrs;
+ if phdr.p_type != PT_LOAD {
+ self.next()
+ } else {
+ Some(Segment {
+ addr: phdr.p_vaddr as usize + self.base,
+ size: phdr.p_memsz as usize,
+ mod_rel_addr: phdr.p_vaddr as usize,
+ flags: Perm(phdr.p_flags),
+ })
+ }
+ })
+ }
+}
+
+/// Represents an ELF DSO (Dynamic Shared Object). This type references
+/// the data stored in the actual DSO rather than making its own copy.
+struct Dso<'a> {
+ /// The dynamic linker always gives us a name, even if the name is empty.
+ /// In the case of the main executable this name will be empty. In the case
+ /// of a shared object it will be the soname (see DT_SONAME).
+ name: &'a str,
+ /// On Fuchsia virtually all binaries have build IDs but this is not a strict
+ /// requirement. There's no way to match up DSO information with a real ELF
+ /// file afterwards if there is no build_id so we require that every DSO
+ /// have one here. DSO's without a build_id are ignored.
+ build_id: &'a [u8],
+
+ base: usize,
+ phdrs: &'a [Elf_Phdr],
+}
+
+impl Dso<'_> {
+ /// Returns an iterator over Segments in this DSO.
+ fn segments(&self) -> SegmentIter<'_> {
+ SegmentIter {
+ phdrs: self.phdrs.as_ref(),
+ base: self.base,
+ }
+ }
+}
+
+struct HexSlice<'a> {
+ bytes: &'a [u8],
+}
+
+impl fmt::Display for HexSlice<'_> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ for byte in self.bytes {
+ write!(f, "{:02x}", byte)?;
+ }
+ Ok(())
+ }
+}
+
+fn get_build_id<'a>(info: &'a dl_phdr_info) -> Option<&'a [u8]> {
+ for phdr in info.program_headers() {
+ if phdr.phdr.p_type == PT_NOTE {
+ for note in phdr.notes() {
+ if note.tipe == NT_GNU_BUILD_ID && (note.name == b"GNU\0" || note.name == b"GNU") {
+ return Some(note.desc);
+ }
+ }
+ }
+ }
+ None
+}
+
+/// These errors encode issues that arise while parsing information about
+/// each DSO.
+enum Error {
+ /// NameError means that an error occurred while converting a C style string
+ /// into a rust string.
+ NameError(core::str::Utf8Error),
+ /// BuildIDError means that we didn't find a build ID. This could either be
+ /// because the DSO had no build ID or because the segment containing the
+ /// build ID was malformed.
+ BuildIDError,
+}
+
+/// Calls either 'dso' or 'error' for each DSO linked into the process by the
+/// dynamic linker.
+///
+/// # Arguments
+///
+/// * `visitor` - A DsoPrinter that will have one of eats methods called foreach DSO.
+fn for_each_dso(mut visitor: &mut DsoPrinter<'_, '_>) {
+ extern "C" fn callback(
+ info: &dl_phdr_info,
+ _size: usize,
+ visitor: &mut DsoPrinter<'_, '_>,
+ ) -> i32 {
+ // dl_iterate_phdr ensures that info.name will point to a valid
+ // location.
+ let name_len = unsafe { libc::strlen(info.name) };
+ let name_slice: &[u8] =
+ unsafe { core::slice::from_raw_parts(info.name as *const u8, name_len) };
+ let name = match core::str::from_utf8(name_slice) {
+ Ok(name) => name,
+ Err(err) => {
+ return visitor.error(Error::NameError(err)) as i32;
+ }
+ };
+ let build_id = match get_build_id(info) {
+ Some(build_id) => build_id,
+ None => {
+ return visitor.error(Error::BuildIDError) as i32;
+ }
+ };
+ visitor.dso(Dso {
+ name: name,
+ build_id: build_id,
+ phdrs: info.phdr_slice(),
+ base: info.addr as usize,
+ }) as i32
+ }
+ unsafe { dl_iterate_phdr(callback, &mut visitor) };
+}
+
+struct DsoPrinter<'a, 'b> {
+ writer: &'a mut core::fmt::Formatter<'b>,
+ module_count: usize,
+ error: core::fmt::Result,
+}
+
+impl DsoPrinter<'_, '_> {
+ fn dso(&mut self, dso: Dso<'_>) -> bool {
+ let mut write = || {
+ write!(
+ self.writer,
+ "{{{{{{module:{:#x}:{}:elf:{}}}}}}}\n",
+ self.module_count,
+ dso.name,
+ HexSlice {
+ bytes: dso.build_id.as_ref()
+ }
+ )?;
+ for seg in dso.segments() {
+ write!(
+ self.writer,
+ "{{{{{{mmap:{:#x}:{:#x}:load:{:#x}:{}:{:#x}}}}}}}\n",
+ seg.addr, seg.size, self.module_count, seg.flags, seg.mod_rel_addr
+ )?;
+ }
+ self.module_count += 1;
+ Ok(())
+ };
+ match write() {
+ Ok(()) => false,
+ Err(err) => {
+ self.error = Err(err);
+ true
+ }
+ }
+ }
+ fn error(&mut self, _error: Error) -> bool {
+ false
+ }
+}
+
+/// This function prints the Fuchsia symbolizer markup for all information contained in a DSO.
+pub fn print_dso_context(out: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ out.write_str("{{{reset}}}\n")?;
+ let mut visitor = DsoPrinter {
+ writer: out,
+ module_count: 0,
+ error: Ok(()),
+ };
+ for_each_dso(&mut visitor);
+ visitor.error
+}
diff --git a/vendor/backtrace/src/symbolize/dbghelp.rs b/vendor/backtrace/src/symbolize/dbghelp.rs
new file mode 100644
index 000000000..181dba731
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/dbghelp.rs
@@ -0,0 +1,218 @@
+//! Symbolication strategy using `dbghelp.dll` on Windows, only used for MSVC
+//!
+//! This symbolication strategy, like with backtraces, uses dynamically loaded
+//! information from `dbghelp.dll`. (see `src/dbghelp.rs` for info about why
+//! it's dynamically loaded).
+//!
+//! This API selects its resolution strategy based on the frame provided or the
+//! information we have at hand. If a frame from `StackWalkEx` is given to us
+//! then we use similar APIs to generate correct information about inlined
+//! functions. Otherwise if all we have is an address or an older stack frame
+//! from `StackWalk64` we use the older APIs for symbolication.
+//!
+//! There's a good deal of support in this module, but a good chunk of it is
+//! converting back and forth between Windows types and Rust types. For example
+//! symbols come to us as wide strings which we then convert to utf-8 strings if
+//! we can.
+
+#![allow(bad_style)]
+
+use super::super::{backtrace::StackFrame, dbghelp, windows::*};
+use super::{BytesOrWideString, ResolveWhat, SymbolName};
+use core::char;
+use core::ffi::c_void;
+use core::marker;
+use core::mem;
+use core::slice;
+
+// Store an OsString on std so we can provide the symbol name and filename.
+pub struct Symbol<'a> {
+ name: *const [u8],
+ addr: *mut c_void,
+ line: Option<u32>,
+ filename: Option<*const [u16]>,
+ #[cfg(feature = "std")]
+ _filename_cache: Option<::std::ffi::OsString>,
+ #[cfg(not(feature = "std"))]
+ _filename_cache: (),
+ _marker: marker::PhantomData<&'a i32>,
+}
+
+impl Symbol<'_> {
+ pub fn name(&self) -> Option<SymbolName<'_>> {
+ Some(SymbolName::new(unsafe { &*self.name }))
+ }
+
+ pub fn addr(&self) -> Option<*mut c_void> {
+ Some(self.addr as *mut _)
+ }
+
+ pub fn filename_raw(&self) -> Option<BytesOrWideString<'_>> {
+ self.filename
+ .map(|slice| unsafe { BytesOrWideString::Wide(&*slice) })
+ }
+
+ pub fn colno(&self) -> Option<u32> {
+ None
+ }
+
+ pub fn lineno(&self) -> Option<u32> {
+ self.line
+ }
+
+ #[cfg(feature = "std")]
+ pub fn filename(&self) -> Option<&::std::path::Path> {
+ use std::path::Path;
+
+ self._filename_cache.as_ref().map(Path::new)
+ }
+}
+
+#[repr(C, align(8))]
+struct Aligned8<T>(T);
+
+pub unsafe fn resolve(what: ResolveWhat<'_>, cb: &mut dyn FnMut(&super::Symbol)) {
+ // Ensure this process's symbols are initialized
+ let dbghelp = match dbghelp::init() {
+ Ok(dbghelp) => dbghelp,
+ Err(()) => return, // oh well...
+ };
+
+ match what {
+ ResolveWhat::Address(_) => resolve_without_inline(&dbghelp, what.address_or_ip(), cb),
+ ResolveWhat::Frame(frame) => match &frame.inner.stack_frame {
+ StackFrame::New(frame) => resolve_with_inline(&dbghelp, frame, cb),
+ StackFrame::Old(_) => resolve_without_inline(&dbghelp, frame.ip(), cb),
+ },
+ }
+}
+
+unsafe fn resolve_with_inline(
+ dbghelp: &dbghelp::Init,
+ frame: &STACKFRAME_EX,
+ cb: &mut dyn FnMut(&super::Symbol),
+) {
+ do_resolve(
+ |info| {
+ dbghelp.SymFromInlineContextW()(
+ GetCurrentProcess(),
+ super::adjust_ip(frame.AddrPC.Offset as *mut _) as u64,
+ frame.InlineFrameContext,
+ &mut 0,
+ info,
+ )
+ },
+ |line| {
+ dbghelp.SymGetLineFromInlineContextW()(
+ GetCurrentProcess(),
+ super::adjust_ip(frame.AddrPC.Offset as *mut _) as u64,
+ frame.InlineFrameContext,
+ 0,
+ &mut 0,
+ line,
+ )
+ },
+ cb,
+ )
+}
+
+unsafe fn resolve_without_inline(
+ dbghelp: &dbghelp::Init,
+ addr: *mut c_void,
+ cb: &mut dyn FnMut(&super::Symbol),
+) {
+ do_resolve(
+ |info| dbghelp.SymFromAddrW()(GetCurrentProcess(), addr as DWORD64, &mut 0, info),
+ |line| dbghelp.SymGetLineFromAddrW64()(GetCurrentProcess(), addr as DWORD64, &mut 0, line),
+ cb,
+ )
+}
+
+unsafe fn do_resolve(
+ sym_from_addr: impl FnOnce(*mut SYMBOL_INFOW) -> BOOL,
+ get_line_from_addr: impl FnOnce(&mut IMAGEHLP_LINEW64) -> BOOL,
+ cb: &mut dyn FnMut(&super::Symbol),
+) {
+ const SIZE: usize = 2 * MAX_SYM_NAME + mem::size_of::<SYMBOL_INFOW>();
+ let mut data = Aligned8([0u8; SIZE]);
+ let data = &mut data.0;
+ let info = &mut *(data.as_mut_ptr() as *mut SYMBOL_INFOW);
+ info.MaxNameLen = MAX_SYM_NAME as ULONG;
+ // the struct size in C. the value is different to
+ // `size_of::<SYMBOL_INFOW>() - MAX_SYM_NAME + 1` (== 81)
+ // due to struct alignment.
+ info.SizeOfStruct = 88;
+
+ if sym_from_addr(info) != TRUE {
+ return;
+ }
+
+ // If the symbol name is greater than MaxNameLen, SymFromAddrW will
+ // give a buffer of (MaxNameLen - 1) characters and set NameLen to
+ // the real value.
+ let name_len = ::core::cmp::min(info.NameLen as usize, info.MaxNameLen as usize - 1);
+ let name_ptr = info.Name.as_ptr() as *const u16;
+ let name = slice::from_raw_parts(name_ptr, name_len);
+
+ // Reencode the utf-16 symbol to utf-8 so we can use `SymbolName::new` like
+ // all other platforms
+ let mut name_len = 0;
+ let mut name_buffer = [0; 256];
+ {
+ let mut remaining = &mut name_buffer[..];
+ for c in char::decode_utf16(name.iter().cloned()) {
+ let c = c.unwrap_or(char::REPLACEMENT_CHARACTER);
+ let len = c.len_utf8();
+ if len < remaining.len() {
+ c.encode_utf8(remaining);
+ let tmp = remaining;
+ remaining = &mut tmp[len..];
+ name_len += len;
+ } else {
+ break;
+ }
+ }
+ }
+ let name = &name_buffer[..name_len] as *const [u8];
+
+ let mut line = mem::zeroed::<IMAGEHLP_LINEW64>();
+ line.SizeOfStruct = mem::size_of::<IMAGEHLP_LINEW64>() as DWORD;
+
+ let mut filename = None;
+ let mut lineno = None;
+ if get_line_from_addr(&mut line) == TRUE {
+ lineno = Some(line.LineNumber as u32);
+
+ let base = line.FileName;
+ let mut len = 0;
+ while *base.offset(len) != 0 {
+ len += 1;
+ }
+
+ let len = len as usize;
+
+ filename = Some(slice::from_raw_parts(base, len) as *const [u16]);
+ }
+
+ cb(&super::Symbol {
+ inner: Symbol {
+ name,
+ addr: info.Address as *mut _,
+ line: lineno,
+ filename,
+ _filename_cache: cache(filename),
+ _marker: marker::PhantomData,
+ },
+ })
+}
+
+#[cfg(feature = "std")]
+unsafe fn cache(filename: Option<*const [u16]>) -> Option<::std::ffi::OsString> {
+ use std::os::windows::ffi::OsStringExt;
+ filename.map(|f| ::std::ffi::OsString::from_wide(&*f))
+}
+
+#[cfg(not(feature = "std"))]
+unsafe fn cache(_filename: Option<*const [u16]>) {}
+
+pub unsafe fn clear_symbol_cache() {}
diff --git a/vendor/backtrace/src/symbolize/gimli.rs b/vendor/backtrace/src/symbolize/gimli.rs
new file mode 100644
index 000000000..5f10122dd
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli.rs
@@ -0,0 +1,462 @@
+//! Support for symbolication using the `gimli` crate on crates.io
+//!
+//! This is the default symbolication implementation for Rust.
+
+use self::gimli::read::EndianSlice;
+use self::gimli::NativeEndian as Endian;
+use self::mmap::Mmap;
+use self::stash::Stash;
+use super::BytesOrWideString;
+use super::ResolveWhat;
+use super::SymbolName;
+use addr2line::gimli;
+use core::convert::TryInto;
+use core::mem;
+use core::u32;
+use libc::c_void;
+use mystd::ffi::OsString;
+use mystd::fs::File;
+use mystd::path::Path;
+use mystd::prelude::v1::*;
+
+#[cfg(backtrace_in_libstd)]
+mod mystd {
+ pub use crate::*;
+}
+#[cfg(not(backtrace_in_libstd))]
+extern crate std as mystd;
+
+cfg_if::cfg_if! {
+ if #[cfg(windows)] {
+ #[path = "gimli/mmap_windows.rs"]
+ mod mmap;
+ } else if #[cfg(any(
+ target_os = "android",
+ target_os = "freebsd",
+ target_os = "fuchsia",
+ target_os = "haiku",
+ target_os = "ios",
+ target_os = "linux",
+ target_os = "macos",
+ target_os = "openbsd",
+ target_os = "solaris",
+ target_os = "illumos",
+ ))] {
+ #[path = "gimli/mmap_unix.rs"]
+ mod mmap;
+ } else {
+ #[path = "gimli/mmap_fake.rs"]
+ mod mmap;
+ }
+}
+
+mod stash;
+
+const MAPPINGS_CACHE_SIZE: usize = 4;
+
+struct Mapping {
+ // 'static lifetime is a lie to hack around lack of support for self-referential structs.
+ cx: Context<'static>,
+ _map: Mmap,
+ _stash: Stash,
+}
+
+enum Either<A, B> {
+ #[allow(dead_code)]
+ A(A),
+ B(B),
+}
+
+impl Mapping {
+ /// Creates a `Mapping` by ensuring that the `data` specified is used to
+ /// create a `Context` and it can only borrow from that or the `Stash` of
+ /// decompressed sections or auxiliary data.
+ fn mk<F>(data: Mmap, mk: F) -> Option<Mapping>
+ where
+ F: for<'a> FnOnce(&'a [u8], &'a Stash) -> Option<Context<'a>>,
+ {
+ Mapping::mk_or_other(data, move |data, stash| {
+ let cx = mk(data, stash)?;
+ Some(Either::B(cx))
+ })
+ }
+
+ /// Creates a `Mapping` from `data`, or if the closure decides to, returns a
+ /// different mapping.
+ fn mk_or_other<F>(data: Mmap, mk: F) -> Option<Mapping>
+ where
+ F: for<'a> FnOnce(&'a [u8], &'a Stash) -> Option<Either<Mapping, Context<'a>>>,
+ {
+ let stash = Stash::new();
+ let cx = match mk(&data, &stash)? {
+ Either::A(mapping) => return Some(mapping),
+ Either::B(cx) => cx,
+ };
+ Some(Mapping {
+ // Convert to 'static lifetimes since the symbols should
+ // only borrow `map` and `stash` and we're preserving them below.
+ cx: unsafe { core::mem::transmute::<Context<'_>, Context<'static>>(cx) },
+ _map: data,
+ _stash: stash,
+ })
+ }
+}
+
+struct Context<'a> {
+ dwarf: addr2line::Context<EndianSlice<'a, Endian>>,
+ object: Object<'a>,
+}
+
+impl<'data> Context<'data> {
+ fn new(
+ stash: &'data Stash,
+ object: Object<'data>,
+ sup: Option<Object<'data>>,
+ ) -> Option<Context<'data>> {
+ let mut sections = gimli::Dwarf::load(|id| -> Result<_, ()> {
+ let data = object.section(stash, id.name()).unwrap_or(&[]);
+ Ok(EndianSlice::new(data, Endian))
+ })
+ .ok()?;
+
+ if let Some(sup) = sup {
+ sections
+ .load_sup(|id| -> Result<_, ()> {
+ let data = sup.section(stash, id.name()).unwrap_or(&[]);
+ Ok(EndianSlice::new(data, Endian))
+ })
+ .ok()?;
+ }
+ let dwarf = addr2line::Context::from_dwarf(sections).ok()?;
+
+ Some(Context { dwarf, object })
+ }
+}
+
+fn mmap(path: &Path) -> Option<Mmap> {
+ let file = File::open(path).ok()?;
+ let len = file.metadata().ok()?.len().try_into().ok()?;
+ unsafe { Mmap::map(&file, len) }
+}
+
+cfg_if::cfg_if! {
+ if #[cfg(windows)] {
+ mod coff;
+ use self::coff::Object;
+ } else if #[cfg(any(
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "tvos",
+ target_os = "watchos",
+ ))] {
+ mod macho;
+ use self::macho::Object;
+ } else {
+ mod elf;
+ use self::elf::Object;
+ }
+}
+
+cfg_if::cfg_if! {
+ if #[cfg(windows)] {
+ mod libs_windows;
+ use libs_windows::native_libraries;
+ } else if #[cfg(any(
+ target_os = "macos",
+ target_os = "ios",
+ target_os = "tvos",
+ target_os = "watchos",
+ ))] {
+ mod libs_macos;
+ use libs_macos::native_libraries;
+ } else if #[cfg(target_os = "illumos")] {
+ mod libs_illumos;
+ use libs_illumos::native_libraries;
+ } else if #[cfg(all(
+ any(
+ target_os = "linux",
+ target_os = "fuchsia",
+ target_os = "freebsd",
+ target_os = "openbsd",
+ all(target_os = "android", feature = "dl_iterate_phdr"),
+ ),
+ not(target_env = "uclibc"),
+ ))] {
+ mod libs_dl_iterate_phdr;
+ use libs_dl_iterate_phdr::native_libraries;
+ } else if #[cfg(target_env = "libnx")] {
+ mod libs_libnx;
+ use libs_libnx::native_libraries;
+ } else if #[cfg(target_os = "haiku")] {
+ mod libs_haiku;
+ use libs_haiku::native_libraries;
+ } else {
+ // Everything else should doesn't know how to load native libraries.
+ fn native_libraries() -> Vec<Library> {
+ Vec::new()
+ }
+ }
+}
+
+#[derive(Default)]
+struct Cache {
+ /// All known shared libraries that have been loaded.
+ libraries: Vec<Library>,
+
+ /// Mappings cache where we retain parsed dwarf information.
+ ///
+ /// This list has a fixed capacity for its entire lifetime which never
+ /// increases. The `usize` element of each pair is an index into `libraries`
+ /// above where `usize::max_value()` represents the current executable. The
+ /// `Mapping` is corresponding parsed dwarf information.
+ ///
+ /// Note that this is basically an LRU cache and we'll be shifting things
+ /// around in here as we symbolize addresses.
+ mappings: Vec<(usize, Mapping)>,
+}
+
+struct Library {
+ name: OsString,
+ /// Segments of this library loaded into memory, and where they're loaded.
+ segments: Vec<LibrarySegment>,
+ /// The "bias" of this library, typically where it's loaded into memory.
+ /// This value is added to each segment's stated address to get the actual
+ /// virtual memory address that the segment is loaded into. Additionally
+ /// this bias is subtracted from real virtual memory addresses to index into
+ /// debuginfo and the symbol table.
+ bias: usize,
+}
+
+struct LibrarySegment {
+ /// The stated address of this segment in the object file. This is not
+ /// actually where the segment is loaded, but rather this address plus the
+ /// containing library's `bias` is where to find it.
+ stated_virtual_memory_address: usize,
+ /// The size of this segment in memory.
+ len: usize,
+}
+
+// unsafe because this is required to be externally synchronized
+pub unsafe fn clear_symbol_cache() {
+ Cache::with_global(|cache| cache.mappings.clear());
+}
+
+impl Cache {
+ fn new() -> Cache {
+ Cache {
+ mappings: Vec::with_capacity(MAPPINGS_CACHE_SIZE),
+ libraries: native_libraries(),
+ }
+ }
+
+ // unsafe because this is required to be externally synchronized
+ unsafe fn with_global(f: impl FnOnce(&mut Self)) {
+ // A very small, very simple LRU cache for debug info mappings.
+ //
+ // The hit rate should be very high, since the typical stack doesn't cross
+ // between many shared libraries.
+ //
+ // The `addr2line::Context` structures are pretty expensive to create. Its
+ // cost is expected to be amortized by subsequent `locate` queries, which
+ // leverage the structures built when constructing `addr2line::Context`s to
+ // get nice speedups. If we didn't have this cache, that amortization would
+ // never happen, and symbolicating backtraces would be ssssllllooooowwww.
+ static mut MAPPINGS_CACHE: Option<Cache> = None;
+
+ f(MAPPINGS_CACHE.get_or_insert_with(|| Cache::new()))
+ }
+
+ fn avma_to_svma(&self, addr: *const u8) -> Option<(usize, *const u8)> {
+ self.libraries
+ .iter()
+ .enumerate()
+ .filter_map(|(i, lib)| {
+ // First up, test if this `lib` has any segment containing the
+ // `addr` (handling relocation). If this check passes then we
+ // can continue below and actually translate the address.
+ //
+ // Note that we're using `wrapping_add` here to avoid overflow
+ // checks. It's been seen in the wild that the SVMA + bias
+ // computation overflows. It seems a bit odd that would happen
+ // but there's not a huge amount we can do about it other than
+ // probably just ignore those segments since they're likely
+ // pointing off into space. This originally came up in
+ // rust-lang/backtrace-rs#329.
+ if !lib.segments.iter().any(|s| {
+ let svma = s.stated_virtual_memory_address;
+ let start = svma.wrapping_add(lib.bias);
+ let end = start.wrapping_add(s.len);
+ let address = addr as usize;
+ start <= address && address < end
+ }) {
+ return None;
+ }
+
+ // Now that we know `lib` contains `addr`, we can offset with
+ // the bias to find the stated virtual memory address.
+ let svma = (addr as usize).wrapping_sub(lib.bias);
+ Some((i, svma as *const u8))
+ })
+ .next()
+ }
+
+ fn mapping_for_lib<'a>(&'a mut self, lib: usize) -> Option<&'a mut Context<'a>> {
+ let idx = self.mappings.iter().position(|(idx, _)| *idx == lib);
+
+ // Invariant: after this conditional completes without early returning
+ // from an error, the cache entry for this path is at index 0.
+
+ if let Some(idx) = idx {
+ // When the mapping is already in the cache, move it to the front.
+ if idx != 0 {
+ let entry = self.mappings.remove(idx);
+ self.mappings.insert(0, entry);
+ }
+ } else {
+ // When the mapping is not in the cache, create a new mapping,
+ // insert it into the front of the cache, and evict the oldest cache
+ // entry if necessary.
+ let name = &self.libraries[lib].name;
+ let mapping = Mapping::new(name.as_ref())?;
+
+ if self.mappings.len() == MAPPINGS_CACHE_SIZE {
+ self.mappings.pop();
+ }
+
+ self.mappings.insert(0, (lib, mapping));
+ }
+
+ let cx: &'a mut Context<'static> = &mut self.mappings[0].1.cx;
+ // don't leak the `'static` lifetime, make sure it's scoped to just
+ // ourselves
+ Some(unsafe { mem::transmute::<&'a mut Context<'static>, &'a mut Context<'a>>(cx) })
+ }
+}
+
+pub unsafe fn resolve(what: ResolveWhat<'_>, cb: &mut dyn FnMut(&super::Symbol)) {
+ let addr = what.address_or_ip();
+ let mut call = |sym: Symbol<'_>| {
+ // Extend the lifetime of `sym` to `'static` since we are unfortunately
+ // required to here, but it's only ever going out as a reference so no
+ // reference to it should be persisted beyond this frame anyway.
+ let sym = mem::transmute::<Symbol<'_>, Symbol<'static>>(sym);
+ (cb)(&super::Symbol { inner: sym });
+ };
+
+ Cache::with_global(|cache| {
+ let (lib, addr) = match cache.avma_to_svma(addr as *const u8) {
+ Some(pair) => pair,
+ None => return,
+ };
+
+ // Finally, get a cached mapping or create a new mapping for this file, and
+ // evaluate the DWARF info to find the file/line/name for this address.
+ let cx = match cache.mapping_for_lib(lib) {
+ Some(cx) => cx,
+ None => return,
+ };
+ let mut any_frames = false;
+ if let Ok(mut frames) = cx.dwarf.find_frames(addr as u64) {
+ while let Ok(Some(frame)) = frames.next() {
+ any_frames = true;
+ let name = match frame.function {
+ Some(f) => Some(f.name.slice()),
+ None => cx.object.search_symtab(addr as u64),
+ };
+ call(Symbol::Frame {
+ addr: addr as *mut c_void,
+ location: frame.location,
+ name,
+ });
+ }
+ }
+ if !any_frames {
+ if let Some((object_cx, object_addr)) = cx.object.search_object_map(addr as u64) {
+ if let Ok(mut frames) = object_cx.dwarf.find_frames(object_addr) {
+ while let Ok(Some(frame)) = frames.next() {
+ any_frames = true;
+ call(Symbol::Frame {
+ addr: addr as *mut c_void,
+ location: frame.location,
+ name: frame.function.map(|f| f.name.slice()),
+ });
+ }
+ }
+ }
+ }
+ if !any_frames {
+ if let Some(name) = cx.object.search_symtab(addr as u64) {
+ call(Symbol::Symtab {
+ addr: addr as *mut c_void,
+ name,
+ });
+ }
+ }
+ });
+}
+
+pub enum Symbol<'a> {
+ /// We were able to locate frame information for this symbol, and
+ /// `addr2line`'s frame internally has all the nitty gritty details.
+ Frame {
+ addr: *mut c_void,
+ location: Option<addr2line::Location<'a>>,
+ name: Option<&'a [u8]>,
+ },
+ /// Couldn't find debug information, but we found it in the symbol table of
+ /// the elf executable.
+ Symtab { addr: *mut c_void, name: &'a [u8] },
+}
+
+impl Symbol<'_> {
+ pub fn name(&self) -> Option<SymbolName<'_>> {
+ match self {
+ Symbol::Frame { name, .. } => {
+ let name = name.as_ref()?;
+ Some(SymbolName::new(name))
+ }
+ Symbol::Symtab { name, .. } => Some(SymbolName::new(name)),
+ }
+ }
+
+ pub fn addr(&self) -> Option<*mut c_void> {
+ match self {
+ Symbol::Frame { addr, .. } => Some(*addr),
+ Symbol::Symtab { .. } => None,
+ }
+ }
+
+ pub fn filename_raw(&self) -> Option<BytesOrWideString<'_>> {
+ match self {
+ Symbol::Frame { location, .. } => {
+ let file = location.as_ref()?.file?;
+ Some(BytesOrWideString::Bytes(file.as_bytes()))
+ }
+ Symbol::Symtab { .. } => None,
+ }
+ }
+
+ pub fn filename(&self) -> Option<&Path> {
+ match self {
+ Symbol::Frame { location, .. } => {
+ let file = location.as_ref()?.file?;
+ Some(Path::new(file))
+ }
+ Symbol::Symtab { .. } => None,
+ }
+ }
+
+ pub fn lineno(&self) -> Option<u32> {
+ match self {
+ Symbol::Frame { location, .. } => location.as_ref()?.line,
+ Symbol::Symtab { .. } => None,
+ }
+ }
+
+ pub fn colno(&self) -> Option<u32> {
+ match self {
+ Symbol::Frame { location, .. } => location.as_ref()?.column,
+ Symbol::Symtab { .. } => None,
+ }
+ }
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/coff.rs b/vendor/backtrace/src/symbolize/gimli/coff.rs
new file mode 100644
index 000000000..84d334207
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/coff.rs
@@ -0,0 +1,108 @@
+use super::{Context, Mapping, Path, Stash, Vec};
+use core::convert::TryFrom;
+use object::pe::{ImageDosHeader, ImageSymbol};
+use object::read::pe::{ImageNtHeaders, ImageOptionalHeader, SectionTable};
+use object::read::StringTable;
+use object::LittleEndian as LE;
+
+#[cfg(target_pointer_width = "32")]
+type Pe = object::pe::ImageNtHeaders32;
+#[cfg(target_pointer_width = "64")]
+type Pe = object::pe::ImageNtHeaders64;
+
+impl Mapping {
+ pub fn new(path: &Path) -> Option<Mapping> {
+ let map = super::mmap(path)?;
+ Mapping::mk(map, |data, stash| {
+ Context::new(stash, Object::parse(data)?, None)
+ })
+ }
+}
+
+pub struct Object<'a> {
+ data: &'a [u8],
+ sections: SectionTable<'a>,
+ symbols: Vec<(usize, &'a ImageSymbol)>,
+ strings: StringTable<'a>,
+}
+
+pub fn get_image_base(data: &[u8]) -> Option<usize> {
+ let dos_header = ImageDosHeader::parse(data).ok()?;
+ let mut offset = dos_header.nt_headers_offset().into();
+ let (nt_headers, _) = Pe::parse(data, &mut offset).ok()?;
+ usize::try_from(nt_headers.optional_header().image_base()).ok()
+}
+
+impl<'a> Object<'a> {
+ fn parse(data: &'a [u8]) -> Option<Object<'a>> {
+ let dos_header = ImageDosHeader::parse(data).ok()?;
+ let mut offset = dos_header.nt_headers_offset().into();
+ let (nt_headers, _) = Pe::parse(data, &mut offset).ok()?;
+ let sections = nt_headers.sections(data, offset).ok()?;
+ let symtab = nt_headers.symbols(data).ok()?;
+ let strings = symtab.strings();
+ let image_base = usize::try_from(nt_headers.optional_header().image_base()).ok()?;
+
+ // Collect all the symbols into a local vector which is sorted
+ // by address and contains enough data to learn about the symbol
+ // name. Note that we only look at function symbols and also
+ // note that the sections are 1-indexed because the zero section
+ // is special (apparently).
+ let mut symbols = Vec::new();
+ let mut i = 0;
+ let len = symtab.len();
+ while i < len {
+ let sym = symtab.symbol(i).ok()?;
+ i += 1 + sym.number_of_aux_symbols as usize;
+ let section_number = sym.section_number.get(LE);
+ if sym.derived_type() != object::pe::IMAGE_SYM_DTYPE_FUNCTION || section_number == 0 {
+ continue;
+ }
+ let addr = usize::try_from(sym.value.get(LE)).ok()?;
+ let section = sections
+ .section(usize::try_from(section_number).ok()?)
+ .ok()?;
+ let va = usize::try_from(section.virtual_address.get(LE)).ok()?;
+ symbols.push((addr + va + image_base, sym));
+ }
+ symbols.sort_unstable_by_key(|x| x.0);
+ Some(Object {
+ data,
+ sections,
+ strings,
+ symbols,
+ })
+ }
+
+ pub fn section(&self, _: &Stash, name: &str) -> Option<&'a [u8]> {
+ Some(
+ self.sections
+ .section_by_name(self.strings, name.as_bytes())?
+ .1
+ .pe_data(self.data)
+ .ok()?,
+ )
+ }
+
+ pub fn search_symtab<'b>(&'b self, addr: u64) -> Option<&'b [u8]> {
+ // Note that unlike other formats COFF doesn't embed the size of
+ // each symbol. As a last ditch effort search for the *closest*
+ // symbol to a particular address and return that one. This gets
+ // really wonky once symbols start getting removed because the
+ // symbols returned here can be totally incorrect, but we have
+ // no idea of knowing how to detect that.
+ let addr = usize::try_from(addr).ok()?;
+ let i = match self.symbols.binary_search_by_key(&addr, |p| p.0) {
+ Ok(i) => i,
+ // typically `addr` isn't in the array, but `i` is where
+ // we'd insert it, so the previous position must be the
+ // greatest less than `addr`
+ Err(i) => i.checked_sub(1)?,
+ };
+ self.symbols[i].1.name(self.strings).ok()
+ }
+
+ pub(super) fn search_object_map(&self, _addr: u64) -> Option<(&Context<'_>, u64)> {
+ None
+ }
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/elf.rs b/vendor/backtrace/src/symbolize/gimli/elf.rs
new file mode 100644
index 000000000..bc71ee2c9
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/elf.rs
@@ -0,0 +1,423 @@
+use super::mystd::ffi::{OsStr, OsString};
+use super::mystd::fs;
+use super::mystd::os::unix::ffi::{OsStrExt, OsStringExt};
+use super::mystd::path::{Path, PathBuf};
+use super::Either;
+use super::{Context, Mapping, Stash, Vec};
+use core::convert::{TryFrom, TryInto};
+use core::str;
+use object::elf::{ELFCOMPRESS_ZLIB, ELF_NOTE_GNU, NT_GNU_BUILD_ID, SHF_COMPRESSED};
+use object::read::elf::{CompressionHeader, FileHeader, SectionHeader, SectionTable, Sym};
+use object::read::StringTable;
+use object::{BigEndian, Bytes, NativeEndian};
+
+#[cfg(target_pointer_width = "32")]
+type Elf = object::elf::FileHeader32<NativeEndian>;
+#[cfg(target_pointer_width = "64")]
+type Elf = object::elf::FileHeader64<NativeEndian>;
+
+impl Mapping {
+ pub fn new(path: &Path) -> Option<Mapping> {
+ let map = super::mmap(path)?;
+ Mapping::mk_or_other(map, |map, stash| {
+ let object = Object::parse(&map)?;
+
+ // Try to locate an external debug file using the build ID.
+ if let Some(path_debug) = object.build_id().and_then(locate_build_id) {
+ if let Some(mapping) = Mapping::new_debug(path_debug, None) {
+ return Some(Either::A(mapping));
+ }
+ }
+
+ // Try to locate an external debug file using the GNU debug link section.
+ if let Some((path_debug, crc)) = object.gnu_debuglink_path(path) {
+ if let Some(mapping) = Mapping::new_debug(path_debug, Some(crc)) {
+ return Some(Either::A(mapping));
+ }
+ }
+
+ Context::new(stash, object, None).map(Either::B)
+ })
+ }
+
+ /// Load debuginfo from an external debug file.
+ fn new_debug(path: PathBuf, crc: Option<u32>) -> Option<Mapping> {
+ let map = super::mmap(&path)?;
+ Mapping::mk(map, |map, stash| {
+ let object = Object::parse(&map)?;
+
+ if let Some(_crc) = crc {
+ // TODO: check crc
+ }
+
+ // Try to locate a supplementary object file.
+ if let Some((path_sup, build_id_sup)) = object.gnu_debugaltlink_path(&path) {
+ if let Some(map_sup) = super::mmap(&path_sup) {
+ let map_sup = stash.set_mmap_aux(map_sup);
+ if let Some(sup) = Object::parse(map_sup) {
+ if sup.build_id() == Some(build_id_sup) {
+ return Context::new(stash, object, Some(sup));
+ }
+ }
+ }
+ }
+
+ Context::new(stash, object, None)
+ })
+ }
+}
+
+struct ParsedSym {
+ address: u64,
+ size: u64,
+ name: u32,
+}
+
+pub struct Object<'a> {
+ /// Zero-sized type representing the native endianness.
+ ///
+ /// We could use a literal instead, but this helps ensure correctness.
+ endian: NativeEndian,
+ /// The entire file data.
+ data: &'a [u8],
+ sections: SectionTable<'a, Elf>,
+ strings: StringTable<'a>,
+ /// List of pre-parsed and sorted symbols by base address.
+ syms: Vec<ParsedSym>,
+}
+
+impl<'a> Object<'a> {
+ fn parse(data: &'a [u8]) -> Option<Object<'a>> {
+ let elf = Elf::parse(data).ok()?;
+ let endian = elf.endian().ok()?;
+ let sections = elf.sections(endian, data).ok()?;
+ let mut syms = sections
+ .symbols(endian, data, object::elf::SHT_SYMTAB)
+ .ok()?;
+ if syms.is_empty() {
+ syms = sections
+ .symbols(endian, data, object::elf::SHT_DYNSYM)
+ .ok()?;
+ }
+ let strings = syms.strings();
+
+ let mut syms = syms
+ .iter()
+ // Only look at function/object symbols. This mirrors what
+ // libbacktrace does and in general we're only symbolicating
+ // function addresses in theory. Object symbols correspond
+ // to data, and maybe someone's crazy enough to have a
+ // function go into static data?
+ .filter(|sym| {
+ let st_type = sym.st_type();
+ st_type == object::elf::STT_FUNC || st_type == object::elf::STT_OBJECT
+ })
+ // skip anything that's in an undefined section header,
+ // since it means it's an imported function and we're only
+ // symbolicating with locally defined functions.
+ .filter(|sym| sym.st_shndx(endian) != object::elf::SHN_UNDEF)
+ .map(|sym| {
+ let address = sym.st_value(endian).into();
+ let size = sym.st_size(endian).into();
+ let name = sym.st_name(endian);
+ ParsedSym {
+ address,
+ size,
+ name,
+ }
+ })
+ .collect::<Vec<_>>();
+ syms.sort_unstable_by_key(|s| s.address);
+ Some(Object {
+ endian,
+ data,
+ sections,
+ strings,
+ syms,
+ })
+ }
+
+ pub fn section(&self, stash: &'a Stash, name: &str) -> Option<&'a [u8]> {
+ if let Some(section) = self.section_header(name) {
+ let mut data = Bytes(section.data(self.endian, self.data).ok()?);
+
+ // Check for DWARF-standard (gABI) compression, i.e., as generated
+ // by ld's `--compress-debug-sections=zlib-gabi` flag.
+ let flags: u64 = section.sh_flags(self.endian).into();
+ if (flags & u64::from(SHF_COMPRESSED)) == 0 {
+ // Not compressed.
+ return Some(data.0);
+ }
+
+ let header = data.read::<<Elf as FileHeader>::CompressionHeader>().ok()?;
+ if header.ch_type(self.endian) != ELFCOMPRESS_ZLIB {
+ // Zlib compression is the only known type.
+ return None;
+ }
+ let size = usize::try_from(header.ch_size(self.endian)).ok()?;
+ let buf = stash.allocate(size);
+ decompress_zlib(data.0, buf)?;
+ return Some(buf);
+ }
+
+ // Check for the nonstandard GNU compression format, i.e., as generated
+ // by ld's `--compress-debug-sections=zlib-gnu` flag. This means that if
+ // we're actually asking for `.debug_info` then we need to look up a
+ // section named `.zdebug_info`.
+ if !name.starts_with(".debug_") {
+ return None;
+ }
+ let debug_name = name[7..].as_bytes();
+ let compressed_section = self
+ .sections
+ .iter()
+ .filter_map(|header| {
+ let name = self.sections.section_name(self.endian, header).ok()?;
+ if name.starts_with(b".zdebug_") && &name[8..] == debug_name {
+ Some(header)
+ } else {
+ None
+ }
+ })
+ .next()?;
+ let mut data = Bytes(compressed_section.data(self.endian, self.data).ok()?);
+ if data.read_bytes(8).ok()?.0 != b"ZLIB\0\0\0\0" {
+ return None;
+ }
+ let size = usize::try_from(data.read::<object::U32Bytes<_>>().ok()?.get(BigEndian)).ok()?;
+ let buf = stash.allocate(size);
+ decompress_zlib(data.0, buf)?;
+ Some(buf)
+ }
+
+ fn section_header(&self, name: &str) -> Option<&<Elf as FileHeader>::SectionHeader> {
+ self.sections
+ .section_by_name(self.endian, name.as_bytes())
+ .map(|(_index, section)| section)
+ }
+
+ pub fn search_symtab<'b>(&'b self, addr: u64) -> Option<&'b [u8]> {
+ // Same sort of binary search as Windows above
+ let i = match self.syms.binary_search_by_key(&addr, |sym| sym.address) {
+ Ok(i) => i,
+ Err(i) => i.checked_sub(1)?,
+ };
+ let sym = self.syms.get(i)?;
+ if sym.address <= addr && addr <= sym.address + sym.size {
+ self.strings.get(sym.name).ok()
+ } else {
+ None
+ }
+ }
+
+ pub(super) fn search_object_map(&self, _addr: u64) -> Option<(&Context<'_>, u64)> {
+ None
+ }
+
+ fn build_id(&self) -> Option<&'a [u8]> {
+ for section in self.sections.iter() {
+ if let Ok(Some(mut notes)) = section.notes(self.endian, self.data) {
+ while let Ok(Some(note)) = notes.next() {
+ if note.name() == ELF_NOTE_GNU && note.n_type(self.endian) == NT_GNU_BUILD_ID {
+ return Some(note.desc());
+ }
+ }
+ }
+ }
+ None
+ }
+
+ // The contents of the ".gnu_debuglink" section is documented at:
+ // https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html
+ fn gnu_debuglink_path(&self, path: &Path) -> Option<(PathBuf, u32)> {
+ let section = self.section_header(".gnu_debuglink")?;
+ let data = section.data(self.endian, self.data).ok()?;
+ let len = data.iter().position(|x| *x == 0)?;
+ let filename = &data[..len];
+ let offset = (len + 1 + 3) & !3;
+ let crc_bytes = data
+ .get(offset..offset + 4)
+ .and_then(|bytes| bytes.try_into().ok())?;
+ let crc = u32::from_ne_bytes(crc_bytes);
+ let path_debug = locate_debuglink(path, filename)?;
+ Some((path_debug, crc))
+ }
+
+ // The format of the ".gnu_debugaltlink" section is based on gdb.
+ fn gnu_debugaltlink_path(&self, path: &Path) -> Option<(PathBuf, &'a [u8])> {
+ let section = self.section_header(".gnu_debugaltlink")?;
+ let data = section.data(self.endian, self.data).ok()?;
+ let len = data.iter().position(|x| *x == 0)?;
+ let filename = &data[..len];
+ let build_id = &data[len + 1..];
+ let path_sup = locate_debugaltlink(path, filename, build_id)?;
+ Some((path_sup, build_id))
+ }
+}
+
+fn decompress_zlib(input: &[u8], output: &mut [u8]) -> Option<()> {
+ use miniz_oxide::inflate::core::inflate_flags::{
+ TINFL_FLAG_PARSE_ZLIB_HEADER, TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF,
+ };
+ use miniz_oxide::inflate::core::{decompress, DecompressorOxide};
+ use miniz_oxide::inflate::TINFLStatus;
+
+ let (status, in_read, out_read) = decompress(
+ &mut DecompressorOxide::new(),
+ input,
+ output,
+ 0,
+ TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF | TINFL_FLAG_PARSE_ZLIB_HEADER,
+ );
+ if status == TINFLStatus::Done && in_read == input.len() && out_read == output.len() {
+ Some(())
+ } else {
+ None
+ }
+}
+
+const DEBUG_PATH: &[u8] = b"/usr/lib/debug";
+
+fn debug_path_exists() -> bool {
+ cfg_if::cfg_if! {
+ if #[cfg(any(target_os = "freebsd", target_os = "linux"))] {
+ use core::sync::atomic::{AtomicU8, Ordering};
+ static DEBUG_PATH_EXISTS: AtomicU8 = AtomicU8::new(0);
+
+ let mut exists = DEBUG_PATH_EXISTS.load(Ordering::Relaxed);
+ if exists == 0 {
+ exists = if Path::new(OsStr::from_bytes(DEBUG_PATH)).is_dir() {
+ 1
+ } else {
+ 2
+ };
+ DEBUG_PATH_EXISTS.store(exists, Ordering::Relaxed);
+ }
+ exists == 1
+ } else {
+ false
+ }
+ }
+}
+
+/// Locate a debug file based on its build ID.
+///
+/// The format of build id paths is documented at:
+/// https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html
+fn locate_build_id(build_id: &[u8]) -> Option<PathBuf> {
+ const BUILD_ID_PATH: &[u8] = b"/usr/lib/debug/.build-id/";
+ const BUILD_ID_SUFFIX: &[u8] = b".debug";
+
+ if build_id.len() < 2 {
+ return None;
+ }
+
+ if !debug_path_exists() {
+ return None;
+ }
+
+ let mut path =
+ Vec::with_capacity(BUILD_ID_PATH.len() + BUILD_ID_SUFFIX.len() + build_id.len() * 2 + 1);
+ path.extend(BUILD_ID_PATH);
+ path.push(hex(build_id[0] >> 4));
+ path.push(hex(build_id[0] & 0xf));
+ path.push(b'/');
+ for byte in &build_id[1..] {
+ path.push(hex(byte >> 4));
+ path.push(hex(byte & 0xf));
+ }
+ path.extend(BUILD_ID_SUFFIX);
+ Some(PathBuf::from(OsString::from_vec(path)))
+}
+
+fn hex(byte: u8) -> u8 {
+ if byte < 10 {
+ b'0' + byte
+ } else {
+ b'a' + byte - 10
+ }
+}
+
+/// Locate a file specified in a `.gnu_debuglink` section.
+///
+/// `path` is the file containing the section.
+/// `filename` is from the contents of the section.
+///
+/// Search order is based on gdb, documented at:
+/// https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html
+///
+/// gdb also allows the user to customize the debug search path, but we don't.
+///
+/// gdb also supports debuginfod, but we don't yet.
+fn locate_debuglink(path: &Path, filename: &[u8]) -> Option<PathBuf> {
+ let path = fs::canonicalize(path).ok()?;
+ let parent = path.parent()?;
+ let mut f = PathBuf::from(OsString::with_capacity(
+ DEBUG_PATH.len() + parent.as_os_str().len() + filename.len() + 2,
+ ));
+ let filename = Path::new(OsStr::from_bytes(filename));
+
+ // Try "/parent/filename" if it differs from "path"
+ f.push(parent);
+ f.push(filename);
+ if f != path && f.is_file() {
+ return Some(f);
+ }
+
+ // Try "/parent/.debug/filename"
+ let mut s = OsString::from(f);
+ s.clear();
+ f = PathBuf::from(s);
+ f.push(parent);
+ f.push(".debug");
+ f.push(filename);
+ if f.is_file() {
+ return Some(f);
+ }
+
+ if debug_path_exists() {
+ // Try "/usr/lib/debug/parent/filename"
+ let mut s = OsString::from(f);
+ s.clear();
+ f = PathBuf::from(s);
+ f.push(OsStr::from_bytes(DEBUG_PATH));
+ f.push(parent.strip_prefix("/").unwrap());
+ f.push(filename);
+ if f.is_file() {
+ return Some(f);
+ }
+ }
+
+ None
+}
+
+/// Locate a file specified in a `.gnu_debugaltlink` section.
+///
+/// `path` is the file containing the section.
+/// `filename` and `build_id` are the contents of the section.
+///
+/// Search order is based on gdb:
+/// - filename, which is either absolute or relative to `path`
+/// - the build ID path under `BUILD_ID_PATH`
+///
+/// gdb also allows the user to customize the debug search path, but we don't.
+///
+/// gdb also supports debuginfod, but we don't yet.
+fn locate_debugaltlink(path: &Path, filename: &[u8], build_id: &[u8]) -> Option<PathBuf> {
+ let filename = Path::new(OsStr::from_bytes(filename));
+ if filename.is_absolute() {
+ if filename.is_file() {
+ return Some(filename.into());
+ }
+ } else {
+ let path = fs::canonicalize(path).ok()?;
+ let parent = path.parent()?;
+ let mut f = PathBuf::from(parent);
+ f.push(filename);
+ if f.is_file() {
+ return Some(f);
+ }
+ }
+
+ locate_build_id(build_id)
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/libs_dl_iterate_phdr.rs b/vendor/backtrace/src/symbolize/gimli/libs_dl_iterate_phdr.rs
new file mode 100644
index 000000000..a011e6080
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/libs_dl_iterate_phdr.rs
@@ -0,0 +1,53 @@
+// Other Unix (e.g. Linux) platforms use ELF as an object file format
+// and typically implement an API called `dl_iterate_phdr` to load
+// native libraries.
+
+use super::mystd::borrow::ToOwned;
+use super::mystd::env;
+use super::mystd::ffi::{CStr, OsStr};
+use super::mystd::os::unix::prelude::*;
+use super::{Library, LibrarySegment, OsString, Vec};
+use core::slice;
+
+pub(super) fn native_libraries() -> Vec<Library> {
+ let mut ret = Vec::new();
+ unsafe {
+ libc::dl_iterate_phdr(Some(callback), &mut ret as *mut Vec<_> as *mut _);
+ }
+ return ret;
+}
+
+// `info` should be a valid pointers.
+// `vec` should be a valid pointer to a `std::Vec`.
+unsafe extern "C" fn callback(
+ info: *mut libc::dl_phdr_info,
+ _size: libc::size_t,
+ vec: *mut libc::c_void,
+) -> libc::c_int {
+ let info = &*info;
+ let libs = &mut *(vec as *mut Vec<Library>);
+ let is_main_prog = info.dlpi_name.is_null() || *info.dlpi_name == 0;
+ let name = if is_main_prog {
+ if libs.is_empty() {
+ env::current_exe().map(|e| e.into()).unwrap_or_default()
+ } else {
+ OsString::new()
+ }
+ } else {
+ let bytes = CStr::from_ptr(info.dlpi_name).to_bytes();
+ OsStr::from_bytes(bytes).to_owned()
+ };
+ let headers = slice::from_raw_parts(info.dlpi_phdr, info.dlpi_phnum as usize);
+ libs.push(Library {
+ name,
+ segments: headers
+ .iter()
+ .map(|header| LibrarySegment {
+ len: (*header).p_memsz as usize,
+ stated_virtual_memory_address: (*header).p_vaddr as usize,
+ })
+ .collect(),
+ bias: info.dlpi_addr as usize,
+ });
+ 0
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/libs_haiku.rs b/vendor/backtrace/src/symbolize/gimli/libs_haiku.rs
new file mode 100644
index 000000000..87e023e69
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/libs_haiku.rs
@@ -0,0 +1,48 @@
+// Haiku implements the image_info struct and the get_next_image_info()
+// functions to iterate through the loaded executable images. The
+// image_info struct contains a pointer to the start of the .text
+// section within the virtual address space, as well as the size of
+// that section. All the read-only segments of the ELF-binary are in
+// that part of the address space.
+
+use super::mystd::borrow::ToOwned;
+use super::mystd::ffi::{CStr, OsStr};
+use super::mystd::mem::MaybeUninit;
+use super::mystd::os::unix::prelude::*;
+use super::{Library, LibrarySegment, Vec};
+
+pub(super) fn native_libraries() -> Vec<Library> {
+ let mut libraries: Vec<Library> = Vec::new();
+
+ unsafe {
+ let mut info = MaybeUninit::<libc::image_info>::zeroed();
+ let mut cookie: i32 = 0;
+ // Load the first image to get a valid info struct
+ let mut status =
+ libc::get_next_image_info(libc::B_CURRENT_TEAM, &mut cookie, info.as_mut_ptr());
+ if status != libc::B_OK {
+ return libraries;
+ }
+ let mut info = info.assume_init();
+
+ while status == libc::B_OK {
+ let mut segments = Vec::new();
+ segments.push(LibrarySegment {
+ stated_virtual_memory_address: 0,
+ len: info.text_size as usize,
+ });
+
+ let bytes = CStr::from_ptr(info.name.as_ptr()).to_bytes();
+ let name = OsStr::from_bytes(bytes).to_owned();
+ libraries.push(Library {
+ name: name,
+ segments: segments,
+ bias: info.text as usize,
+ });
+
+ status = libc::get_next_image_info(libc::B_CURRENT_TEAM, &mut cookie, &mut info);
+ }
+ }
+
+ libraries
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/libs_illumos.rs b/vendor/backtrace/src/symbolize/gimli/libs_illumos.rs
new file mode 100644
index 000000000..e64975e0c
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/libs_illumos.rs
@@ -0,0 +1,99 @@
+use super::mystd::borrow::ToOwned;
+use super::mystd::ffi::{CStr, OsStr};
+use super::mystd::os::unix::prelude::*;
+use super::{Library, LibrarySegment, Vec};
+use core::mem;
+use object::NativeEndian;
+
+#[cfg(target_pointer_width = "64")]
+use object::elf::{FileHeader64 as FileHeader, ProgramHeader64 as ProgramHeader};
+
+type EHdr = FileHeader<NativeEndian>;
+type PHdr = ProgramHeader<NativeEndian>;
+
+#[repr(C)]
+struct LinkMap {
+ l_addr: libc::c_ulong,
+ l_name: *const libc::c_char,
+ l_ld: *const libc::c_void,
+ l_next: *const LinkMap,
+ l_prev: *const LinkMap,
+ l_refname: *const libc::c_char,
+}
+
+const RTLD_SELF: *const libc::c_void = -3isize as *const libc::c_void;
+const RTLD_DI_LINKMAP: libc::c_int = 2;
+
+extern "C" {
+ fn dlinfo(
+ handle: *const libc::c_void,
+ request: libc::c_int,
+ p: *mut libc::c_void,
+ ) -> libc::c_int;
+}
+
+pub(super) fn native_libraries() -> Vec<Library> {
+ let mut libs = Vec::new();
+
+ // Request the current link map from the runtime linker:
+ let map = unsafe {
+ let mut map: *const LinkMap = mem::zeroed();
+ if dlinfo(
+ RTLD_SELF,
+ RTLD_DI_LINKMAP,
+ (&mut map) as *mut *const LinkMap as *mut libc::c_void,
+ ) != 0
+ {
+ return libs;
+ }
+ map
+ };
+
+ // Each entry in the link map represents a loaded object:
+ let mut l = map;
+ while !l.is_null() {
+ // Fetch the fully qualified path of the loaded object:
+ let bytes = unsafe { CStr::from_ptr((*l).l_name) }.to_bytes();
+ let name = OsStr::from_bytes(bytes).to_owned();
+
+ // The base address of the object loaded into memory:
+ let addr = unsafe { (*l).l_addr };
+
+ // Use the ELF header for this object to locate the program
+ // header:
+ let e: *const EHdr = unsafe { (*l).l_addr as *const EHdr };
+ let phoff = unsafe { (*e).e_phoff }.get(NativeEndian);
+ let phnum = unsafe { (*e).e_phnum }.get(NativeEndian);
+ let etype = unsafe { (*e).e_type }.get(NativeEndian);
+
+ let phdr: *const PHdr = (addr + phoff) as *const PHdr;
+ let phdr = unsafe { core::slice::from_raw_parts(phdr, phnum as usize) };
+
+ libs.push(Library {
+ name,
+ segments: phdr
+ .iter()
+ .map(|p| {
+ let memsz = p.p_memsz.get(NativeEndian);
+ let vaddr = p.p_vaddr.get(NativeEndian);
+ LibrarySegment {
+ len: memsz as usize,
+ stated_virtual_memory_address: vaddr as usize,
+ }
+ })
+ .collect(),
+ bias: if etype == object::elf::ET_EXEC {
+ // Program header addresses for the base executable are
+ // already absolute.
+ 0
+ } else {
+ // Other addresses are relative to the object base.
+ addr as usize
+ },
+ });
+
+ l = unsafe { (*l).l_next };
+ }
+
+ libs
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/libs_libnx.rs b/vendor/backtrace/src/symbolize/gimli/libs_libnx.rs
new file mode 100644
index 000000000..93b5ba17e
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/libs_libnx.rs
@@ -0,0 +1,27 @@
+use super::{Library, LibrarySegment, Vec};
+
+// DevkitA64 doesn't natively support debug info, but the build system will
+// place debug info at the path `romfs:/debug_info.elf`.
+pub(super) fn native_libraries() -> Vec<Library> {
+ extern "C" {
+ static __start__: u8;
+ }
+
+ let bias = unsafe { &__start__ } as *const u8 as usize;
+
+ let mut ret = Vec::new();
+ let mut segments = Vec::new();
+ segments.push(LibrarySegment {
+ stated_virtual_memory_address: 0,
+ len: usize::max_value() - bias,
+ });
+
+ let path = "romfs:/debug_info.elf";
+ ret.push(Library {
+ name: path.into(),
+ segments,
+ bias,
+ });
+
+ ret
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/libs_macos.rs b/vendor/backtrace/src/symbolize/gimli/libs_macos.rs
new file mode 100644
index 000000000..17703b88a
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/libs_macos.rs
@@ -0,0 +1,146 @@
+#![allow(deprecated)]
+
+use super::mystd::ffi::{CStr, OsStr};
+use super::mystd::os::unix::prelude::*;
+use super::mystd::prelude::v1::*;
+use super::{Library, LibrarySegment};
+use core::convert::TryInto;
+use core::mem;
+
+pub(super) fn native_libraries() -> Vec<Library> {
+ let mut ret = Vec::new();
+ let images = unsafe { libc::_dyld_image_count() };
+ for i in 0..images {
+ ret.extend(native_library(i));
+ }
+ return ret;
+}
+
+fn native_library(i: u32) -> Option<Library> {
+ use object::macho;
+ use object::read::macho::{MachHeader, Segment};
+ use object::NativeEndian;
+
+ // Fetch the name of this library which corresponds to the path of
+ // where to load it as well.
+ let name = unsafe {
+ let name = libc::_dyld_get_image_name(i);
+ if name.is_null() {
+ return None;
+ }
+ CStr::from_ptr(name)
+ };
+
+ // Load the image header of this library and delegate to `object` to
+ // parse all the load commands so we can figure out all the segments
+ // involved here.
+ let (mut load_commands, endian) = unsafe {
+ let header = libc::_dyld_get_image_header(i);
+ if header.is_null() {
+ return None;
+ }
+ match (*header).magic {
+ macho::MH_MAGIC => {
+ let endian = NativeEndian;
+ let header = &*(header as *const macho::MachHeader32<NativeEndian>);
+ let data = core::slice::from_raw_parts(
+ header as *const _ as *const u8,
+ mem::size_of_val(header) + header.sizeofcmds.get(endian) as usize,
+ );
+ (header.load_commands(endian, data, 0).ok()?, endian)
+ }
+ macho::MH_MAGIC_64 => {
+ let endian = NativeEndian;
+ let header = &*(header as *const macho::MachHeader64<NativeEndian>);
+ let data = core::slice::from_raw_parts(
+ header as *const _ as *const u8,
+ mem::size_of_val(header) + header.sizeofcmds.get(endian) as usize,
+ );
+ (header.load_commands(endian, data, 0).ok()?, endian)
+ }
+ _ => return None,
+ }
+ };
+
+ // Iterate over the segments and register known regions for segments
+ // that we find. Additionally record information bout text segments
+ // for processing later, see comments below.
+ let mut segments = Vec::new();
+ let mut first_text = 0;
+ let mut text_fileoff_zero = false;
+ while let Some(cmd) = load_commands.next().ok()? {
+ if let Some((seg, _)) = cmd.segment_32().ok()? {
+ if seg.name() == b"__TEXT" {
+ first_text = segments.len();
+ if seg.fileoff(endian) == 0 && seg.filesize(endian) > 0 {
+ text_fileoff_zero = true;
+ }
+ }
+ segments.push(LibrarySegment {
+ len: seg.vmsize(endian).try_into().ok()?,
+ stated_virtual_memory_address: seg.vmaddr(endian).try_into().ok()?,
+ });
+ }
+ if let Some((seg, _)) = cmd.segment_64().ok()? {
+ if seg.name() == b"__TEXT" {
+ first_text = segments.len();
+ if seg.fileoff(endian) == 0 && seg.filesize(endian) > 0 {
+ text_fileoff_zero = true;
+ }
+ }
+ segments.push(LibrarySegment {
+ len: seg.vmsize(endian).try_into().ok()?,
+ stated_virtual_memory_address: seg.vmaddr(endian).try_into().ok()?,
+ });
+ }
+ }
+
+ // Determine the "slide" for this library which ends up being the
+ // bias we use to figure out where in memory objects are loaded.
+ // This is a bit of a weird computation though and is the result of
+ // trying a few things in the wild and seeing what sticks.
+ //
+ // The general idea is that the `bias` plus a segment's
+ // `stated_virtual_memory_address` is going to be where in the
+ // actual address space the segment resides. The other thing we rely
+ // on though is that a real address minus the `bias` is the index to
+ // look up in the symbol table and debuginfo.
+ //
+ // It turns out, though, that for system loaded libraries these
+ // calculations are incorrect. For native executables, however, it
+ // appears correct. Lifting some logic from LLDB's source it has
+ // some special-casing for the first `__TEXT` section loaded from
+ // file offset 0 with a nonzero size. For whatever reason when this
+ // is present it appears to mean that the symbol table is relative
+ // to just the vmaddr slide for the library. If it's *not* present
+ // then the symbol table is relative to the the vmaddr slide plus
+ // the segment's stated address.
+ //
+ // To handle this situation if we *don't* find a text section at
+ // file offset zero then we increase the bias by the first text
+ // sections's stated address and decrease all stated addresses by
+ // that amount as well. That way the symbol table is always appears
+ // relative to the library's bias amount. This appears to have the
+ // right results for symbolizing via the symbol table.
+ //
+ // Honestly I'm not entirely sure whether this is right or if
+ // there's something else that should indicate how to do this. For
+ // now though this seems to work well enough (?) and we should
+ // always be able to tweak this over time if necessary.
+ //
+ // For some more information see #318
+ let mut slide = unsafe { libc::_dyld_get_image_vmaddr_slide(i) as usize };
+ if !text_fileoff_zero {
+ let adjust = segments[first_text].stated_virtual_memory_address;
+ for segment in segments.iter_mut() {
+ segment.stated_virtual_memory_address -= adjust;
+ }
+ slide += adjust;
+ }
+
+ Some(Library {
+ name: OsStr::from_bytes(name.to_bytes()).to_owned(),
+ segments,
+ bias: slide,
+ })
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/libs_windows.rs b/vendor/backtrace/src/symbolize/gimli/libs_windows.rs
new file mode 100644
index 000000000..b47ed4245
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/libs_windows.rs
@@ -0,0 +1,89 @@
+use super::super::super::windows::*;
+use super::mystd::os::windows::prelude::*;
+use super::{coff, mmap, Library, LibrarySegment, OsString};
+use alloc::vec;
+use alloc::vec::Vec;
+use core::mem;
+use core::mem::MaybeUninit;
+
+// For loading native libraries on Windows, see some discussion on
+// rust-lang/rust#71060 for the various strategies here.
+pub(super) fn native_libraries() -> Vec<Library> {
+ let mut ret = Vec::new();
+ unsafe {
+ add_loaded_images(&mut ret);
+ }
+ return ret;
+}
+
+unsafe fn add_loaded_images(ret: &mut Vec<Library>) {
+ let snap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, 0);
+ if snap == INVALID_HANDLE_VALUE {
+ return;
+ }
+
+ let mut me = MaybeUninit::<MODULEENTRY32W>::zeroed().assume_init();
+ me.dwSize = mem::size_of_val(&me) as DWORD;
+ if Module32FirstW(snap, &mut me) == TRUE {
+ loop {
+ if let Some(lib) = load_library(&me) {
+ ret.push(lib);
+ }
+
+ if Module32NextW(snap, &mut me) != TRUE {
+ break;
+ }
+ }
+ }
+
+ CloseHandle(snap);
+}
+
+unsafe fn load_library(me: &MODULEENTRY32W) -> Option<Library> {
+ let pos = me
+ .szExePath
+ .iter()
+ .position(|i| *i == 0)
+ .unwrap_or(me.szExePath.len());
+ let name = OsString::from_wide(&me.szExePath[..pos]);
+
+ // MinGW libraries currently don't support ASLR
+ // (rust-lang/rust#16514), but DLLs can still be relocated around in
+ // the address space. It appears that addresses in debug info are
+ // all as-if this library was loaded at its "image base", which is a
+ // field in its COFF file headers. Since this is what debuginfo
+ // seems to list we parse the symbol table and store addresses as if
+ // the library was loaded at "image base" as well.
+ //
+ // The library may not be loaded at "image base", however.
+ // (presumably something else may be loaded there?) This is where
+ // the `bias` field comes into play, and we need to figure out the
+ // value of `bias` here. Unfortunately though it's not clear how to
+ // acquire this from a loaded module. What we do have, however, is
+ // the actual load address (`modBaseAddr`).
+ //
+ // As a bit of a cop-out for now we mmap the file, read the file
+ // header information, then drop the mmap. This is wasteful because
+ // we'll probably reopen the mmap later, but this should work well
+ // enough for now.
+ //
+ // Once we have the `image_base` (desired load location) and the
+ // `base_addr` (actual load location) we can fill in the `bias`
+ // (difference between the actual and desired) and then the stated
+ // address of each segment is the `image_base` since that's what the
+ // file says.
+ //
+ // For now it appears that unlike ELF/MachO we can make do with one
+ // segment per library, using `modBaseSize` as the whole size.
+ let mmap = mmap(name.as_ref())?;
+ let image_base = coff::get_image_base(&mmap)?;
+ let base_addr = me.modBaseAddr as usize;
+ Some(Library {
+ name,
+ bias: base_addr.wrapping_sub(image_base),
+ segments: vec![LibrarySegment {
+ stated_virtual_memory_address: image_base,
+ len: me.modBaseSize as usize,
+ }],
+ })
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/macho.rs b/vendor/backtrace/src/symbolize/gimli/macho.rs
new file mode 100644
index 000000000..ec5673843
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/macho.rs
@@ -0,0 +1,324 @@
+use super::{Box, Context, Mapping, Path, Stash, Vec};
+use core::convert::TryInto;
+use object::macho;
+use object::read::macho::{MachHeader, Nlist, Section, Segment as _};
+use object::{Bytes, NativeEndian};
+
+#[cfg(target_pointer_width = "32")]
+type Mach = object::macho::MachHeader32<NativeEndian>;
+#[cfg(target_pointer_width = "64")]
+type Mach = object::macho::MachHeader64<NativeEndian>;
+type MachSegment = <Mach as MachHeader>::Segment;
+type MachSection = <Mach as MachHeader>::Section;
+type MachNlist = <Mach as MachHeader>::Nlist;
+
+impl Mapping {
+ // The loading path for OSX is is so different we just have a completely
+ // different implementation of the function here. On OSX we need to go
+ // probing the filesystem for a bunch of files.
+ pub fn new(path: &Path) -> Option<Mapping> {
+ // First up we need to load the unique UUID which is stored in the macho
+ // header of the file we're reading, specified at `path`.
+ let map = super::mmap(path)?;
+ let (macho, data) = find_header(&map)?;
+ let endian = macho.endian().ok()?;
+ let uuid = macho.uuid(endian, data, 0).ok()?;
+
+ // Next we need to look for a `*.dSYM` file. For now we just probe the
+ // containing directory and look around for something that matches
+ // `*.dSYM`. Once it's found we root through the dwarf resources that it
+ // contains and try to find a macho file which has a matching UUID as
+ // the one of our own file. If we find a match that's the dwarf file we
+ // want to return.
+ if let Some(uuid) = uuid {
+ if let Some(parent) = path.parent() {
+ if let Some(mapping) = Mapping::load_dsym(parent, uuid) {
+ return Some(mapping);
+ }
+ }
+ }
+
+ // Looks like nothing matched our UUID, so let's at least return our own
+ // file. This should have the symbol table for at least some
+ // symbolication purposes.
+ Mapping::mk(map, |data, stash| {
+ let (macho, data) = find_header(data)?;
+ let endian = macho.endian().ok()?;
+ let obj = Object::parse(macho, endian, data)?;
+ Context::new(stash, obj, None)
+ })
+ }
+
+ fn load_dsym(dir: &Path, uuid: [u8; 16]) -> Option<Mapping> {
+ for entry in dir.read_dir().ok()? {
+ let entry = entry.ok()?;
+ let filename = match entry.file_name().into_string() {
+ Ok(name) => name,
+ Err(_) => continue,
+ };
+ if !filename.ends_with(".dSYM") {
+ continue;
+ }
+ let candidates = entry.path().join("Contents/Resources/DWARF");
+ if let Some(mapping) = Mapping::try_dsym_candidate(&candidates, uuid) {
+ return Some(mapping);
+ }
+ }
+ None
+ }
+
+ fn try_dsym_candidate(dir: &Path, uuid: [u8; 16]) -> Option<Mapping> {
+ // Look for files in the `DWARF` directory which have a matching uuid to
+ // the original object file. If we find one then we found the debug
+ // information.
+ for entry in dir.read_dir().ok()? {
+ let entry = entry.ok()?;
+ let map = super::mmap(&entry.path())?;
+ let candidate = Mapping::mk(map, |data, stash| {
+ let (macho, data) = find_header(data)?;
+ let endian = macho.endian().ok()?;
+ let entry_uuid = macho.uuid(endian, data, 0).ok()??;
+ if entry_uuid != uuid {
+ return None;
+ }
+ let obj = Object::parse(macho, endian, data)?;
+ Context::new(stash, obj, None)
+ });
+ if let Some(candidate) = candidate {
+ return Some(candidate);
+ }
+ }
+
+ None
+ }
+}
+
+fn find_header(data: &'_ [u8]) -> Option<(&'_ Mach, &'_ [u8])> {
+ use object::endian::BigEndian;
+
+ let desired_cpu = || {
+ if cfg!(target_arch = "x86") {
+ Some(macho::CPU_TYPE_X86)
+ } else if cfg!(target_arch = "x86_64") {
+ Some(macho::CPU_TYPE_X86_64)
+ } else if cfg!(target_arch = "arm") {
+ Some(macho::CPU_TYPE_ARM)
+ } else if cfg!(target_arch = "aarch64") {
+ Some(macho::CPU_TYPE_ARM64)
+ } else {
+ None
+ }
+ };
+
+ let mut data = Bytes(data);
+ match data
+ .clone()
+ .read::<object::endian::U32<NativeEndian>>()
+ .ok()?
+ .get(NativeEndian)
+ {
+ macho::MH_MAGIC_64 | macho::MH_CIGAM_64 | macho::MH_MAGIC | macho::MH_CIGAM => {}
+
+ macho::FAT_MAGIC | macho::FAT_CIGAM => {
+ let mut header_data = data;
+ let endian = BigEndian;
+ let header = header_data.read::<macho::FatHeader>().ok()?;
+ let nfat = header.nfat_arch.get(endian);
+ let arch = (0..nfat)
+ .filter_map(|_| header_data.read::<macho::FatArch32>().ok())
+ .find(|arch| desired_cpu() == Some(arch.cputype.get(endian)))?;
+ let offset = arch.offset.get(endian);
+ let size = arch.size.get(endian);
+ data = data
+ .read_bytes_at(offset.try_into().ok()?, size.try_into().ok()?)
+ .ok()?;
+ }
+
+ macho::FAT_MAGIC_64 | macho::FAT_CIGAM_64 => {
+ let mut header_data = data;
+ let endian = BigEndian;
+ let header = header_data.read::<macho::FatHeader>().ok()?;
+ let nfat = header.nfat_arch.get(endian);
+ let arch = (0..nfat)
+ .filter_map(|_| header_data.read::<macho::FatArch64>().ok())
+ .find(|arch| desired_cpu() == Some(arch.cputype.get(endian)))?;
+ let offset = arch.offset.get(endian);
+ let size = arch.size.get(endian);
+ data = data
+ .read_bytes_at(offset.try_into().ok()?, size.try_into().ok()?)
+ .ok()?;
+ }
+
+ _ => return None,
+ }
+
+ Mach::parse(data.0, 0).ok().map(|h| (h, data.0))
+}
+
+// This is used both for executables/libraries and source object files.
+pub struct Object<'a> {
+ endian: NativeEndian,
+ data: &'a [u8],
+ dwarf: Option<&'a [MachSection]>,
+ syms: Vec<(&'a [u8], u64)>,
+ syms_sort_by_name: bool,
+ // Only set for executables/libraries, and not the source object files.
+ object_map: Option<object::ObjectMap<'a>>,
+ // The outer Option is for lazy loading, and the inner Option allows load errors to be cached.
+ object_mappings: Box<[Option<Option<Mapping>>]>,
+}
+
+impl<'a> Object<'a> {
+ fn parse(mach: &'a Mach, endian: NativeEndian, data: &'a [u8]) -> Option<Object<'a>> {
+ let is_object = mach.filetype(endian) == object::macho::MH_OBJECT;
+ let mut dwarf = None;
+ let mut syms = Vec::new();
+ let mut syms_sort_by_name = false;
+ let mut commands = mach.load_commands(endian, data, 0).ok()?;
+ let mut object_map = None;
+ let mut object_mappings = Vec::new();
+ while let Ok(Some(command)) = commands.next() {
+ if let Some((segment, section_data)) = MachSegment::from_command(command).ok()? {
+ // Object files should have all sections in a single unnamed segment load command.
+ if segment.name() == b"__DWARF" || (is_object && segment.name() == b"") {
+ dwarf = segment.sections(endian, section_data).ok();
+ }
+ } else if let Some(symtab) = command.symtab().ok()? {
+ let symbols = symtab.symbols::<Mach, _>(endian, data).ok()?;
+ syms = symbols
+ .iter()
+ .filter_map(|nlist: &MachNlist| {
+ let name = nlist.name(endian, symbols.strings()).ok()?;
+ if name.len() > 0 && nlist.is_definition() {
+ Some((name, u64::from(nlist.n_value(endian))))
+ } else {
+ None
+ }
+ })
+ .collect();
+ if is_object {
+ // We never search object file symbols by address.
+ // Instead, we already know the symbol name from the executable, and we
+ // need to search by name to find the matching symbol in the object file.
+ syms.sort_unstable_by_key(|(name, _)| *name);
+ syms_sort_by_name = true;
+ } else {
+ syms.sort_unstable_by_key(|(_, addr)| *addr);
+ let map = symbols.object_map(endian);
+ object_mappings.resize_with(map.objects().len(), || None);
+ object_map = Some(map);
+ }
+ }
+ }
+
+ Some(Object {
+ endian,
+ data,
+ dwarf,
+ syms,
+ syms_sort_by_name,
+ object_map,
+ object_mappings: object_mappings.into_boxed_slice(),
+ })
+ }
+
+ pub fn section(&self, _: &Stash, name: &str) -> Option<&'a [u8]> {
+ let name = name.as_bytes();
+ let dwarf = self.dwarf?;
+ let section = dwarf.into_iter().find(|section| {
+ let section_name = section.name();
+ section_name == name || {
+ section_name.starts_with(b"__")
+ && name.starts_with(b".")
+ && &section_name[2..] == &name[1..]
+ }
+ })?;
+ Some(section.data(self.endian, self.data).ok()?)
+ }
+
+ pub fn search_symtab<'b>(&'b self, addr: u64) -> Option<&'b [u8]> {
+ debug_assert!(!self.syms_sort_by_name);
+ let i = match self.syms.binary_search_by_key(&addr, |(_, addr)| *addr) {
+ Ok(i) => i,
+ Err(i) => i.checked_sub(1)?,
+ };
+ let (sym, _addr) = self.syms.get(i)?;
+ Some(sym)
+ }
+
+ /// Try to load a context for an object file.
+ ///
+ /// If dsymutil was not run, then the DWARF may be found in the source object files.
+ pub(super) fn search_object_map<'b>(&'b mut self, addr: u64) -> Option<(&Context<'b>, u64)> {
+ // `object_map` contains a map from addresses to symbols and object paths.
+ // Look up the address and get a mapping for the object.
+ let object_map = self.object_map.as_ref()?;
+ let symbol = object_map.get(addr)?;
+ let object_index = symbol.object_index();
+ let mapping = self.object_mappings.get_mut(object_index)?;
+ if mapping.is_none() {
+ // No cached mapping, so create it.
+ *mapping = Some(object_mapping(object_map.objects().get(object_index)?));
+ }
+ let cx: &'b Context<'static> = &mapping.as_ref()?.as_ref()?.cx;
+ // Don't leak the `'static` lifetime, make sure it's scoped to just ourselves.
+ let cx = unsafe { core::mem::transmute::<&'b Context<'static>, &'b Context<'b>>(cx) };
+
+ // We must translate the address in order to be able to look it up
+ // in the DWARF in the object file.
+ debug_assert!(cx.object.syms.is_empty() || cx.object.syms_sort_by_name);
+ let i = cx
+ .object
+ .syms
+ .binary_search_by_key(&symbol.name(), |(name, _)| *name)
+ .ok()?;
+ let object_symbol = cx.object.syms.get(i)?;
+ let object_addr = addr
+ .wrapping_sub(symbol.address())
+ .wrapping_add(object_symbol.1);
+ Some((cx, object_addr))
+ }
+}
+
+fn object_mapping(path: &[u8]) -> Option<Mapping> {
+ use super::mystd::ffi::OsStr;
+ use super::mystd::os::unix::prelude::*;
+
+ let map;
+
+ // `N_OSO` symbol names can be either `/path/to/object.o` or `/path/to/archive.a(object.o)`.
+ let member_name = if let Some((archive_path, member_name)) = split_archive_path(path) {
+ map = super::mmap(Path::new(OsStr::from_bytes(archive_path)))?;
+ Some(member_name)
+ } else {
+ map = super::mmap(Path::new(OsStr::from_bytes(path)))?;
+ None
+ };
+ Mapping::mk(map, |data, stash| {
+ let data = match member_name {
+ Some(member_name) => {
+ let archive = object::read::archive::ArchiveFile::parse(data).ok()?;
+ let member = archive
+ .members()
+ .filter_map(Result::ok)
+ .find(|m| m.name() == member_name)?;
+ member.data(data).ok()?
+ }
+ None => data,
+ };
+ let (macho, data) = find_header(data)?;
+ let endian = macho.endian().ok()?;
+ let obj = Object::parse(macho, endian, data)?;
+ Context::new(stash, obj, None)
+ })
+}
+
+fn split_archive_path(path: &[u8]) -> Option<(&[u8], &[u8])> {
+ let (last, path) = path.split_last()?;
+ if *last != b')' {
+ return None;
+ }
+ let index = path.iter().position(|&x| x == b'(')?;
+ let (archive, rest) = path.split_at(index);
+ Some((archive, &rest[1..]))
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/mmap_fake.rs b/vendor/backtrace/src/symbolize/gimli/mmap_fake.rs
new file mode 100644
index 000000000..ce5096415
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/mmap_fake.rs
@@ -0,0 +1,25 @@
+use super::{mystd::io::Read, File};
+use alloc::vec::Vec;
+use core::ops::Deref;
+
+pub struct Mmap {
+ vec: Vec<u8>,
+}
+
+impl Mmap {
+ pub unsafe fn map(mut file: &File, len: usize) -> Option<Mmap> {
+ let mut mmap = Mmap {
+ vec: Vec::with_capacity(len),
+ };
+ file.read_to_end(&mut mmap.vec).ok()?;
+ Some(mmap)
+ }
+}
+
+impl Deref for Mmap {
+ type Target = [u8];
+
+ fn deref(&self) -> &[u8] {
+ &self.vec[..]
+ }
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/mmap_unix.rs b/vendor/backtrace/src/symbolize/gimli/mmap_unix.rs
new file mode 100644
index 000000000..5806c9f7e
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/mmap_unix.rs
@@ -0,0 +1,44 @@
+use super::mystd::fs::File;
+use super::mystd::os::unix::prelude::*;
+use core::ops::Deref;
+use core::ptr;
+use core::slice;
+
+pub struct Mmap {
+ ptr: *mut libc::c_void,
+ len: usize,
+}
+
+impl Mmap {
+ pub unsafe fn map(file: &File, len: usize) -> Option<Mmap> {
+ let ptr = libc::mmap(
+ ptr::null_mut(),
+ len,
+ libc::PROT_READ,
+ libc::MAP_PRIVATE,
+ file.as_raw_fd(),
+ 0,
+ );
+ if ptr == libc::MAP_FAILED {
+ return None;
+ }
+ Some(Mmap { ptr, len })
+ }
+}
+
+impl Deref for Mmap {
+ type Target = [u8];
+
+ fn deref(&self) -> &[u8] {
+ unsafe { slice::from_raw_parts(self.ptr as *const u8, self.len) }
+ }
+}
+
+impl Drop for Mmap {
+ fn drop(&mut self) {
+ unsafe {
+ let r = libc::munmap(self.ptr, self.len);
+ debug_assert_eq!(r, 0);
+ }
+ }
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/mmap_windows.rs b/vendor/backtrace/src/symbolize/gimli/mmap_windows.rs
new file mode 100644
index 000000000..22f53fe03
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/mmap_windows.rs
@@ -0,0 +1,57 @@
+use super::super::super::windows::*;
+use super::mystd::fs::File;
+use super::mystd::os::windows::prelude::*;
+use core::ops::Deref;
+use core::ptr;
+use core::slice;
+
+pub struct Mmap {
+ // keep the file alive to prevent it from ebeing deleted which would cause
+ // us to read bad data.
+ _file: File,
+ ptr: *mut c_void,
+ len: usize,
+}
+
+impl Mmap {
+ pub unsafe fn map(file: &File, len: usize) -> Option<Mmap> {
+ let file = file.try_clone().ok()?;
+ let mapping = CreateFileMappingA(
+ file.as_raw_handle() as *mut _,
+ ptr::null_mut(),
+ PAGE_READONLY,
+ 0,
+ 0,
+ ptr::null(),
+ );
+ if mapping.is_null() {
+ return None;
+ }
+ let ptr = MapViewOfFile(mapping, FILE_MAP_READ, 0, 0, len);
+ CloseHandle(mapping);
+ if ptr.is_null() {
+ return None;
+ }
+ Some(Mmap {
+ _file: file,
+ ptr,
+ len,
+ })
+ }
+}
+impl Deref for Mmap {
+ type Target = [u8];
+
+ fn deref(&self) -> &[u8] {
+ unsafe { slice::from_raw_parts(self.ptr as *const u8, self.len) }
+ }
+}
+
+impl Drop for Mmap {
+ fn drop(&mut self) {
+ unsafe {
+ let r = UnmapViewOfFile(self.ptr);
+ debug_assert!(r != 0);
+ }
+ }
+}
diff --git a/vendor/backtrace/src/symbolize/gimli/stash.rs b/vendor/backtrace/src/symbolize/gimli/stash.rs
new file mode 100644
index 000000000..3adfc598a
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/gimli/stash.rs
@@ -0,0 +1,52 @@
+// only used on Linux right now, so allow dead code elsewhere
+#![cfg_attr(not(target_os = "linux"), allow(dead_code))]
+
+use super::Mmap;
+use alloc::vec;
+use alloc::vec::Vec;
+use core::cell::UnsafeCell;
+
+/// A simple arena allocator for byte buffers.
+pub struct Stash {
+ buffers: UnsafeCell<Vec<Vec<u8>>>,
+ mmap_aux: UnsafeCell<Option<Mmap>>,
+}
+
+impl Stash {
+ pub fn new() -> Stash {
+ Stash {
+ buffers: UnsafeCell::new(Vec::new()),
+ mmap_aux: UnsafeCell::new(None),
+ }
+ }
+
+ /// Allocates a buffer of the specified size and returns a mutable reference
+ /// to it.
+ pub fn allocate(&self, size: usize) -> &mut [u8] {
+ // SAFETY: this is the only function that ever constructs a mutable
+ // reference to `self.buffers`.
+ let buffers = unsafe { &mut *self.buffers.get() };
+ let i = buffers.len();
+ buffers.push(vec![0; size]);
+ // SAFETY: we never remove elements from `self.buffers`, so a reference
+ // to the data inside any buffer will live as long as `self` does.
+ &mut buffers[i]
+ }
+
+ /// Stores a `Mmap` for the lifetime of this `Stash`, returning a pointer
+ /// which is scoped to just this lifetime.
+ pub fn set_mmap_aux(&self, map: Mmap) -> &[u8] {
+ // SAFETY: this is the only location for a mutable pointer to
+ // `mmap_aux`, and this structure isn't threadsafe to shared across
+ // threads either. This also is careful to store at most one `mmap_aux`
+ // since overwriting a previous one would invalidate the previous
+ // pointer. Given that though we can safely return a pointer to our
+ // interior-owned contents.
+ unsafe {
+ let mmap_aux = &mut *self.mmap_aux.get();
+ assert!(mmap_aux.is_none());
+ *mmap_aux = Some(map);
+ mmap_aux.as_ref().unwrap()
+ }
+ }
+}
diff --git a/vendor/backtrace/src/symbolize/miri.rs b/vendor/backtrace/src/symbolize/miri.rs
new file mode 100644
index 000000000..5b0dc3084
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/miri.rs
@@ -0,0 +1,56 @@
+use core::ffi::c_void;
+use core::marker::PhantomData;
+
+use super::super::backtrace::miri::{resolve_addr, Frame};
+use super::BytesOrWideString;
+use super::{ResolveWhat, SymbolName};
+
+pub unsafe fn resolve(what: ResolveWhat<'_>, cb: &mut dyn FnMut(&super::Symbol)) {
+ let sym = match what {
+ ResolveWhat::Address(addr) => Symbol {
+ inner: resolve_addr(addr),
+ _unused: PhantomData,
+ },
+ ResolveWhat::Frame(frame) => Symbol {
+ inner: frame.inner.clone(),
+ _unused: PhantomData,
+ },
+ };
+ cb(&super::Symbol { inner: sym })
+}
+
+pub struct Symbol<'a> {
+ inner: Frame,
+ _unused: PhantomData<&'a ()>,
+}
+
+impl<'a> Symbol<'a> {
+ pub fn name(&self) -> Option<SymbolName<'_>> {
+ Some(SymbolName::new(&self.inner.inner.name))
+ }
+
+ pub fn addr(&self) -> Option<*mut c_void> {
+ Some(self.inner.addr)
+ }
+
+ pub fn filename_raw(&self) -> Option<BytesOrWideString<'_>> {
+ Some(BytesOrWideString::Bytes(&self.inner.inner.filename))
+ }
+
+ pub fn lineno(&self) -> Option<u32> {
+ Some(self.inner.inner.lineno)
+ }
+
+ pub fn colno(&self) -> Option<u32> {
+ Some(self.inner.inner.colno)
+ }
+
+ #[cfg(feature = "std")]
+ pub fn filename(&self) -> Option<&std::path::Path> {
+ Some(std::path::Path::new(
+ core::str::from_utf8(&self.inner.inner.filename).unwrap(),
+ ))
+ }
+}
+
+pub unsafe fn clear_symbol_cache() {}
diff --git a/vendor/backtrace/src/symbolize/mod.rs b/vendor/backtrace/src/symbolize/mod.rs
new file mode 100644
index 000000000..dbc346522
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/mod.rs
@@ -0,0 +1,485 @@
+use core::{fmt, str};
+
+cfg_if::cfg_if! {
+ if #[cfg(feature = "std")] {
+ use std::path::Path;
+ use std::prelude::v1::*;
+ }
+}
+
+use super::backtrace::Frame;
+use super::types::BytesOrWideString;
+use core::ffi::c_void;
+use rustc_demangle::{try_demangle, Demangle};
+
+/// Resolve an address to a symbol, passing the symbol to the specified
+/// closure.
+///
+/// This function will look up the given address in areas such as the local
+/// symbol table, dynamic symbol table, or DWARF debug info (depending on the
+/// activated implementation) to find symbols to yield.
+///
+/// The closure may not be called if resolution could not be performed, and it
+/// also may be called more than once in the case of inlined functions.
+///
+/// Symbols yielded represent the execution at the specified `addr`, returning
+/// file/line pairs for that address (if available).
+///
+/// Note that if you have a `Frame` then it's recommended to use the
+/// `resolve_frame` function instead of this one.
+///
+/// # Required features
+///
+/// This function requires the `std` feature of the `backtrace` crate to be
+/// enabled, and the `std` feature is enabled by default.
+///
+/// # Panics
+///
+/// This function strives to never panic, but if the `cb` provided panics then
+/// some platforms will force a double panic to abort the process. Some
+/// platforms use a C library which internally uses callbacks which cannot be
+/// unwound through, so panicking from `cb` may trigger a process abort.
+///
+/// # Example
+///
+/// ```
+/// extern crate backtrace;
+///
+/// fn main() {
+/// backtrace::trace(|frame| {
+/// let ip = frame.ip();
+///
+/// backtrace::resolve(ip, |symbol| {
+/// // ...
+/// });
+///
+/// false // only look at the top frame
+/// });
+/// }
+/// ```
+#[cfg(feature = "std")]
+pub fn resolve<F: FnMut(&Symbol)>(addr: *mut c_void, cb: F) {
+ let _guard = crate::lock::lock();
+ unsafe { resolve_unsynchronized(addr, cb) }
+}
+
+/// Resolve a previously capture frame to a symbol, passing the symbol to the
+/// specified closure.
+///
+/// This function performs the same function as `resolve` except that it takes a
+/// `Frame` as an argument instead of an address. This can allow some platform
+/// implementations of backtracing to provide more accurate symbol information
+/// or information about inline frames for example. It's recommended to use this
+/// if you can.
+///
+/// # Required features
+///
+/// This function requires the `std` feature of the `backtrace` crate to be
+/// enabled, and the `std` feature is enabled by default.
+///
+/// # Panics
+///
+/// This function strives to never panic, but if the `cb` provided panics then
+/// some platforms will force a double panic to abort the process. Some
+/// platforms use a C library which internally uses callbacks which cannot be
+/// unwound through, so panicking from `cb` may trigger a process abort.
+///
+/// # Example
+///
+/// ```
+/// extern crate backtrace;
+///
+/// fn main() {
+/// backtrace::trace(|frame| {
+/// backtrace::resolve_frame(frame, |symbol| {
+/// // ...
+/// });
+///
+/// false // only look at the top frame
+/// });
+/// }
+/// ```
+#[cfg(feature = "std")]
+pub fn resolve_frame<F: FnMut(&Symbol)>(frame: &Frame, cb: F) {
+ let _guard = crate::lock::lock();
+ unsafe { resolve_frame_unsynchronized(frame, cb) }
+}
+
+pub enum ResolveWhat<'a> {
+ Address(*mut c_void),
+ Frame(&'a Frame),
+}
+
+impl<'a> ResolveWhat<'a> {
+ #[allow(dead_code)]
+ fn address_or_ip(&self) -> *mut c_void {
+ match self {
+ ResolveWhat::Address(a) => adjust_ip(*a),
+ ResolveWhat::Frame(f) => adjust_ip(f.ip()),
+ }
+ }
+}
+
+// IP values from stack frames are typically (always?) the instruction
+// *after* the call that's the actual stack trace. Symbolizing this on
+// causes the filename/line number to be one ahead and perhaps into
+// the void if it's near the end of the function.
+//
+// This appears to basically always be the case on all platforms, so we always
+// subtract one from a resolved ip to resolve it to the previous call
+// instruction instead of the instruction being returned to.
+//
+// Ideally we would not do this. Ideally we would require callers of the
+// `resolve` APIs here to manually do the -1 and account that they want location
+// information for the *previous* instruction, not the current. Ideally we'd
+// also expose on `Frame` if we are indeed the address of the next instruction
+// or the current.
+//
+// For now though this is a pretty niche concern so we just internally always
+// subtract one. Consumers should keep working and getting pretty good results,
+// so we should be good enough.
+fn adjust_ip(a: *mut c_void) -> *mut c_void {
+ if a.is_null() {
+ a
+ } else {
+ (a as usize - 1) as *mut c_void
+ }
+}
+
+/// Same as `resolve`, only unsafe as it's unsynchronized.
+///
+/// This function does not have synchronization guarantees but is available when
+/// the `std` feature of this crate isn't compiled in. See the `resolve`
+/// function for more documentation and examples.
+///
+/// # Panics
+///
+/// See information on `resolve` for caveats on `cb` panicking.
+pub unsafe fn resolve_unsynchronized<F>(addr: *mut c_void, mut cb: F)
+where
+ F: FnMut(&Symbol),
+{
+ imp::resolve(ResolveWhat::Address(addr), &mut cb)
+}
+
+/// Same as `resolve_frame`, only unsafe as it's unsynchronized.
+///
+/// This function does not have synchronization guarantees but is available
+/// when the `std` feature of this crate isn't compiled in. See the
+/// `resolve_frame` function for more documentation and examples.
+///
+/// # Panics
+///
+/// See information on `resolve_frame` for caveats on `cb` panicking.
+pub unsafe fn resolve_frame_unsynchronized<F>(frame: &Frame, mut cb: F)
+where
+ F: FnMut(&Symbol),
+{
+ imp::resolve(ResolveWhat::Frame(frame), &mut cb)
+}
+
+/// A trait representing the resolution of a symbol in a file.
+///
+/// This trait is yielded as a trait object to the closure given to the
+/// `backtrace::resolve` function, and it is virtually dispatched as it's
+/// unknown which implementation is behind it.
+///
+/// A symbol can give contextual information about a function, for example the
+/// name, filename, line number, precise address, etc. Not all information is
+/// always available in a symbol, however, so all methods return an `Option`.
+pub struct Symbol {
+ // TODO: this lifetime bound needs to be persisted eventually to `Symbol`,
+ // but that's currently a breaking change. For now this is safe since
+ // `Symbol` is only ever handed out by reference and can't be cloned.
+ inner: imp::Symbol<'static>,
+}
+
+impl Symbol {
+ /// Returns the name of this function.
+ ///
+ /// The returned structure can be used to query various properties about the
+ /// symbol name:
+ ///
+ /// * The `Display` implementation will print out the demangled symbol.
+ /// * The raw `str` value of the symbol can be accessed (if it's valid
+ /// utf-8).
+ /// * The raw bytes for the symbol name can be accessed.
+ pub fn name(&self) -> Option<SymbolName<'_>> {
+ self.inner.name()
+ }
+
+ /// Returns the starting address of this function.
+ pub fn addr(&self) -> Option<*mut c_void> {
+ self.inner.addr().map(|p| p as *mut _)
+ }
+
+ /// Returns the raw filename as a slice. This is mainly useful for `no_std`
+ /// environments.
+ pub fn filename_raw(&self) -> Option<BytesOrWideString<'_>> {
+ self.inner.filename_raw()
+ }
+
+ /// Returns the column number for where this symbol is currently executing.
+ ///
+ /// Only gimli currently provides a value here and even then only if `filename`
+ /// returns `Some`, and so it is then consequently subject to similar caveats.
+ pub fn colno(&self) -> Option<u32> {
+ self.inner.colno()
+ }
+
+ /// Returns the line number for where this symbol is currently executing.
+ ///
+ /// This return value is typically `Some` if `filename` returns `Some`, and
+ /// is consequently subject to similar caveats.
+ pub fn lineno(&self) -> Option<u32> {
+ self.inner.lineno()
+ }
+
+ /// Returns the file name where this function was defined.
+ ///
+ /// This is currently only available when libbacktrace or gimli is being
+ /// used (e.g. unix platforms other) and when a binary is compiled with
+ /// debuginfo. If neither of these conditions is met then this will likely
+ /// return `None`.
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ #[cfg(feature = "std")]
+ #[allow(unreachable_code)]
+ pub fn filename(&self) -> Option<&Path> {
+ self.inner.filename()
+ }
+}
+
+impl fmt::Debug for Symbol {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut d = f.debug_struct("Symbol");
+ if let Some(name) = self.name() {
+ d.field("name", &name);
+ }
+ if let Some(addr) = self.addr() {
+ d.field("addr", &addr);
+ }
+
+ #[cfg(feature = "std")]
+ {
+ if let Some(filename) = self.filename() {
+ d.field("filename", &filename);
+ }
+ }
+
+ if let Some(lineno) = self.lineno() {
+ d.field("lineno", &lineno);
+ }
+ d.finish()
+ }
+}
+
+cfg_if::cfg_if! {
+ if #[cfg(feature = "cpp_demangle")] {
+ // Maybe a parsed C++ symbol, if parsing the mangled symbol as Rust
+ // failed.
+ struct OptionCppSymbol<'a>(Option<::cpp_demangle::BorrowedSymbol<'a>>);
+
+ impl<'a> OptionCppSymbol<'a> {
+ fn parse(input: &'a [u8]) -> OptionCppSymbol<'a> {
+ OptionCppSymbol(::cpp_demangle::BorrowedSymbol::new(input).ok())
+ }
+
+ fn none() -> OptionCppSymbol<'a> {
+ OptionCppSymbol(None)
+ }
+ }
+ } else {
+ use core::marker::PhantomData;
+
+ // Make sure to keep this zero-sized, so that the `cpp_demangle` feature
+ // has no cost when disabled.
+ struct OptionCppSymbol<'a>(PhantomData<&'a ()>);
+
+ impl<'a> OptionCppSymbol<'a> {
+ fn parse(_: &'a [u8]) -> OptionCppSymbol<'a> {
+ OptionCppSymbol(PhantomData)
+ }
+
+ fn none() -> OptionCppSymbol<'a> {
+ OptionCppSymbol(PhantomData)
+ }
+ }
+ }
+}
+
+/// A wrapper around a symbol name to provide ergonomic accessors to the
+/// demangled name, the raw bytes, the raw string, etc.
+// Allow dead code for when the `cpp_demangle` feature is not enabled.
+#[allow(dead_code)]
+pub struct SymbolName<'a> {
+ bytes: &'a [u8],
+ demangled: Option<Demangle<'a>>,
+ cpp_demangled: OptionCppSymbol<'a>,
+}
+
+impl<'a> SymbolName<'a> {
+ /// Creates a new symbol name from the raw underlying bytes.
+ pub fn new(bytes: &'a [u8]) -> SymbolName<'a> {
+ let str_bytes = str::from_utf8(bytes).ok();
+ let demangled = str_bytes.and_then(|s| try_demangle(s).ok());
+
+ let cpp = if demangled.is_none() {
+ OptionCppSymbol::parse(bytes)
+ } else {
+ OptionCppSymbol::none()
+ };
+
+ SymbolName {
+ bytes: bytes,
+ demangled: demangled,
+ cpp_demangled: cpp,
+ }
+ }
+
+ /// Returns the raw (mangled) symbol name as a `str` if the symbol is valid utf-8.
+ ///
+ /// Use the `Display` implementation if you want the demangled version.
+ pub fn as_str(&self) -> Option<&'a str> {
+ self.demangled
+ .as_ref()
+ .map(|s| s.as_str())
+ .or_else(|| str::from_utf8(self.bytes).ok())
+ }
+
+ /// Returns the raw symbol name as a list of bytes
+ pub fn as_bytes(&self) -> &'a [u8] {
+ self.bytes
+ }
+}
+
+fn format_symbol_name(
+ fmt: fn(&str, &mut fmt::Formatter<'_>) -> fmt::Result,
+ mut bytes: &[u8],
+ f: &mut fmt::Formatter<'_>,
+) -> fmt::Result {
+ while bytes.len() > 0 {
+ match str::from_utf8(bytes) {
+ Ok(name) => {
+ fmt(name, f)?;
+ break;
+ }
+ Err(err) => {
+ fmt("\u{FFFD}", f)?;
+
+ match err.error_len() {
+ Some(len) => bytes = &bytes[err.valid_up_to() + len..],
+ None => break,
+ }
+ }
+ }
+ }
+ Ok(())
+}
+
+cfg_if::cfg_if! {
+ if #[cfg(feature = "cpp_demangle")] {
+ impl<'a> fmt::Display for SymbolName<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if let Some(ref s) = self.demangled {
+ s.fmt(f)
+ } else if let Some(ref cpp) = self.cpp_demangled.0 {
+ cpp.fmt(f)
+ } else {
+ format_symbol_name(fmt::Display::fmt, self.bytes, f)
+ }
+ }
+ }
+ } else {
+ impl<'a> fmt::Display for SymbolName<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if let Some(ref s) = self.demangled {
+ s.fmt(f)
+ } else {
+ format_symbol_name(fmt::Display::fmt, self.bytes, f)
+ }
+ }
+ }
+ }
+}
+
+cfg_if::cfg_if! {
+ if #[cfg(all(feature = "std", feature = "cpp_demangle"))] {
+ impl<'a> fmt::Debug for SymbolName<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ use std::fmt::Write;
+
+ if let Some(ref s) = self.demangled {
+ return s.fmt(f)
+ }
+
+ // This may to print if the demangled symbol isn't actually
+ // valid, so handle the error here gracefully by not propagating
+ // it outwards.
+ if let Some(ref cpp) = self.cpp_demangled.0 {
+ let mut s = String::new();
+ if write!(s, "{}", cpp).is_ok() {
+ return s.fmt(f)
+ }
+ }
+
+ format_symbol_name(fmt::Debug::fmt, self.bytes, f)
+ }
+ }
+ } else {
+ impl<'a> fmt::Debug for SymbolName<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ if let Some(ref s) = self.demangled {
+ s.fmt(f)
+ } else {
+ format_symbol_name(fmt::Debug::fmt, self.bytes, f)
+ }
+ }
+ }
+ }
+}
+
+/// Attempt to reclaim that cached memory used to symbolicate addresses.
+///
+/// This method will attempt to release any global data structures that have
+/// otherwise been cached globally or in the thread which typically represent
+/// parsed DWARF information or similar.
+///
+/// # Caveats
+///
+/// While this function is always available it doesn't actually do anything on
+/// most implementations. Libraries like dbghelp or libbacktrace do not provide
+/// facilities to deallocate state and manage the allocated memory. For now the
+/// `gimli-symbolize` feature of this crate is the only feature where this
+/// function has any effect.
+#[cfg(feature = "std")]
+pub fn clear_symbol_cache() {
+ let _guard = crate::lock::lock();
+ unsafe {
+ imp::clear_symbol_cache();
+ }
+}
+
+cfg_if::cfg_if! {
+ if #[cfg(miri)] {
+ mod miri;
+ use miri as imp;
+ } else if #[cfg(all(windows, target_env = "msvc", not(target_vendor = "uwp")))] {
+ mod dbghelp;
+ use dbghelp as imp;
+ } else if #[cfg(all(
+ any(unix, windows),
+ not(target_vendor = "uwp"),
+ not(target_os = "emscripten"),
+ any(not(backtrace_in_libstd), feature = "backtrace"),
+ ))] {
+ mod gimli;
+ use gimli as imp;
+ } else {
+ mod noop;
+ use noop as imp;
+ }
+}
diff --git a/vendor/backtrace/src/symbolize/noop.rs b/vendor/backtrace/src/symbolize/noop.rs
new file mode 100644
index 000000000..c53336531
--- /dev/null
+++ b/vendor/backtrace/src/symbolize/noop.rs
@@ -0,0 +1,41 @@
+//! Empty symbolication strategy used to compile for platforms that have no
+//! support.
+
+use super::{BytesOrWideString, ResolveWhat, SymbolName};
+use core::ffi::c_void;
+use core::marker;
+
+pub unsafe fn resolve(_addr: ResolveWhat<'_>, _cb: &mut dyn FnMut(&super::Symbol)) {}
+
+pub struct Symbol<'a> {
+ _marker: marker::PhantomData<&'a i32>,
+}
+
+impl Symbol<'_> {
+ pub fn name(&self) -> Option<SymbolName<'_>> {
+ None
+ }
+
+ pub fn addr(&self) -> Option<*mut c_void> {
+ None
+ }
+
+ pub fn filename_raw(&self) -> Option<BytesOrWideString<'_>> {
+ None
+ }
+
+ #[cfg(feature = "std")]
+ pub fn filename(&self) -> Option<&::std::path::Path> {
+ None
+ }
+
+ pub fn lineno(&self) -> Option<u32> {
+ None
+ }
+
+ pub fn colno(&self) -> Option<u32> {
+ None
+ }
+}
+
+pub unsafe fn clear_symbol_cache() {}
diff --git a/vendor/backtrace/src/types.rs b/vendor/backtrace/src/types.rs
new file mode 100644
index 000000000..c7e551059
--- /dev/null
+++ b/vendor/backtrace/src/types.rs
@@ -0,0 +1,83 @@
+//! Platform dependent types.
+
+cfg_if::cfg_if! {
+ if #[cfg(feature = "std")] {
+ use std::borrow::Cow;
+ use std::fmt;
+ use std::path::PathBuf;
+ use std::prelude::v1::*;
+ use std::str;
+ }
+}
+
+/// A platform independent representation of a string. When working with `std`
+/// enabled it is recommended to the convenience methods for providing
+/// conversions to `std` types.
+#[derive(Debug)]
+pub enum BytesOrWideString<'a> {
+ /// A slice, typically provided on Unix platforms.
+ Bytes(&'a [u8]),
+ /// Wide strings typically from Windows.
+ Wide(&'a [u16]),
+}
+
+#[cfg(feature = "std")]
+impl<'a> BytesOrWideString<'a> {
+ /// Lossy converts to a `Cow<str>`, will allocate if `Bytes` is not valid
+ /// UTF-8 or if `BytesOrWideString` is `Wide`.
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn to_str_lossy(&self) -> Cow<'a, str> {
+ use self::BytesOrWideString::*;
+
+ match self {
+ &Bytes(slice) => String::from_utf8_lossy(slice),
+ &Wide(wide) => Cow::Owned(String::from_utf16_lossy(wide)),
+ }
+ }
+
+ /// Provides a `Path` representation of `BytesOrWideString`.
+ ///
+ /// # Required features
+ ///
+ /// This function requires the `std` feature of the `backtrace` crate to be
+ /// enabled, and the `std` feature is enabled by default.
+ pub fn into_path_buf(self) -> PathBuf {
+ #[cfg(unix)]
+ {
+ use std::ffi::OsStr;
+ use std::os::unix::ffi::OsStrExt;
+
+ if let BytesOrWideString::Bytes(slice) = self {
+ return PathBuf::from(OsStr::from_bytes(slice));
+ }
+ }
+
+ #[cfg(windows)]
+ {
+ use std::ffi::OsString;
+ use std::os::windows::ffi::OsStringExt;
+
+ if let BytesOrWideString::Wide(slice) = self {
+ return PathBuf::from(OsString::from_wide(slice));
+ }
+ }
+
+ if let BytesOrWideString::Bytes(b) = self {
+ if let Ok(s) = str::from_utf8(b) {
+ return PathBuf::from(s);
+ }
+ }
+ unreachable!()
+ }
+}
+
+#[cfg(feature = "std")]
+impl<'a> fmt::Display for BytesOrWideString<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ self.to_str_lossy().fmt(f)
+ }
+}
diff --git a/vendor/backtrace/src/windows.rs b/vendor/backtrace/src/windows.rs
new file mode 100644
index 000000000..d091874f1
--- /dev/null
+++ b/vendor/backtrace/src/windows.rs
@@ -0,0 +1,691 @@
+//! A module to define the FFI definitions we use on Windows for `dbghelp.dll`
+//!
+//! This module uses a custom macro, `ffi!`, to wrap all definitions to
+//! automatically generate tests to assert that our definitions here are the
+//! same as `winapi`.
+//!
+//! This module largely exists to integrate into libstd itself where winapi is
+//! not currently available.
+
+#![allow(bad_style, dead_code)]
+
+cfg_if::cfg_if! {
+ if #[cfg(feature = "verify-winapi")] {
+ pub use self::winapi::c_void;
+ pub use self::winapi::HINSTANCE;
+ pub use self::winapi::FARPROC;
+ pub use self::winapi::LPSECURITY_ATTRIBUTES;
+ #[cfg(target_pointer_width = "64")]
+ pub use self::winapi::PUNWIND_HISTORY_TABLE;
+ #[cfg(target_pointer_width = "64")]
+ pub use self::winapi::PRUNTIME_FUNCTION;
+
+ mod winapi {
+ pub use winapi::ctypes::*;
+ pub use winapi::shared::basetsd::*;
+ pub use winapi::shared::minwindef::*;
+ pub use winapi::um::dbghelp::*;
+ pub use winapi::um::fileapi::*;
+ pub use winapi::um::handleapi::*;
+ pub use winapi::um::libloaderapi::*;
+ pub use winapi::um::memoryapi::*;
+ pub use winapi::um::minwinbase::*;
+ pub use winapi::um::processthreadsapi::*;
+ pub use winapi::um::synchapi::*;
+ pub use winapi::um::tlhelp32::*;
+ pub use winapi::um::winbase::*;
+ pub use winapi::um::winnt::*;
+ }
+ } else {
+ pub use core::ffi::c_void;
+ pub type HINSTANCE = *mut c_void;
+ pub type FARPROC = *mut c_void;
+ pub type LPSECURITY_ATTRIBUTES = *mut c_void;
+ #[cfg(target_pointer_width = "64")]
+ pub type PRUNTIME_FUNCTION = *mut c_void;
+ #[cfg(target_pointer_width = "64")]
+ pub type PUNWIND_HISTORY_TABLE = *mut c_void;
+ }
+}
+
+macro_rules! ffi {
+ () => ();
+
+ (#[repr($($r:tt)*)] pub struct $name:ident { $(pub $field:ident: $ty:ty,)* } $($rest:tt)*) => (
+ #[repr($($r)*)]
+ #[cfg(not(feature = "verify-winapi"))]
+ #[derive(Copy, Clone)]
+ pub struct $name {
+ $(pub $field: $ty,)*
+ }
+
+ #[cfg(feature = "verify-winapi")]
+ pub use self::winapi::$name;
+
+ #[test]
+ #[cfg(feature = "verify-winapi")]
+ fn $name() {
+ use core::mem;
+
+ #[repr($($r)*)]
+ pub struct $name {
+ $(pub $field: $ty,)*
+ }
+
+ assert_eq!(
+ mem::size_of::<$name>(),
+ mem::size_of::<winapi::$name>(),
+ concat!("size of ", stringify!($name), " is wrong"),
+ );
+ assert_eq!(
+ mem::align_of::<$name>(),
+ mem::align_of::<winapi::$name>(),
+ concat!("align of ", stringify!($name), " is wrong"),
+ );
+
+ type Winapi = winapi::$name;
+
+ fn assert_same<T>(_: T, _: T) {}
+
+ unsafe {
+ let a = &*(mem::align_of::<$name>() as *const $name);
+ let b = &*(mem::align_of::<Winapi>() as *const Winapi);
+
+ $(
+ ffi!(@test_fields a b $field $ty);
+ )*
+ }
+ }
+
+ ffi!($($rest)*);
+ );
+
+ // Handling verification against unions in winapi requires some special care
+ (@test_fields $a:ident $b:ident FltSave $ty:ty) => (
+ // Skip this field on x86_64 `CONTEXT` since it's a union and a bit funny
+ );
+ (@test_fields $a:ident $b:ident D $ty:ty) => ({
+ let a = &$a.D;
+ let b = $b.D();
+ assert_same(a, b);
+ assert_eq!(a as *const $ty, b as *const $ty, "misplaced field D");
+ });
+ (@test_fields $a:ident $b:ident s $ty:ty) => ({
+ let a = &$a.s;
+ let b = $b.s();
+ assert_same(a, b);
+ assert_eq!(a as *const $ty, b as *const $ty, "misplaced field s");
+ });
+
+ // Otherwise test all fields normally.
+ (@test_fields $a:ident $b:ident $field:ident $ty:ty) => ({
+ let a = &$a.$field;
+ let b = &$b.$field;
+ assert_same(a, b);
+ assert_eq!(a as *const $ty, b as *const $ty,
+ concat!("misplaced field ", stringify!($field)));
+ });
+
+ (pub type $name:ident = $ty:ty; $($rest:tt)*) => (
+ pub type $name = $ty;
+
+ #[cfg(feature = "verify-winapi")]
+ #[allow(dead_code)]
+ const $name: () = {
+ fn _foo() {
+ trait SameType {}
+ impl<T> SameType for (T, T) {}
+ fn assert_same<T: SameType>() {}
+
+ assert_same::<($name, winapi::$name)>();
+ }
+ };
+
+ ffi!($($rest)*);
+ );
+
+ (pub const $name:ident: $ty:ty = $val:expr; $($rest:tt)*) => (
+ pub const $name: $ty = $val;
+
+ #[cfg(feature = "verify-winapi")]
+ #[allow(unused_imports)]
+ mod $name {
+ use super::*;
+ #[test]
+ fn assert_valid() {
+ let x: $ty = winapi::$name;
+ assert_eq!(x, $val);
+ }
+ }
+
+
+ ffi!($($rest)*);
+ );
+
+ (extern "system" { $(pub fn $name:ident($($args:tt)*) -> $ret:ty;)* } $($rest:tt)*) => (
+ extern "system" {
+ $(pub fn $name($($args)*) -> $ret;)*
+ }
+
+ $(
+ #[cfg(feature = "verify-winapi")]
+ mod $name {
+ #[test]
+ fn assert_same() {
+ use super::*;
+
+ assert_eq!($name as usize, winapi::$name as usize);
+ let mut x: unsafe extern "system" fn($($args)*) -> $ret;
+ x = $name;
+ drop(x);
+ x = winapi::$name;
+ drop(x);
+ }
+ }
+ )*
+
+ ffi!($($rest)*);
+ );
+
+ (impl $name:ident { $($i:tt)* } $($rest:tt)*) => (
+ #[cfg(not(feature = "verify-winapi"))]
+ impl $name {
+ $($i)*
+ }
+
+ ffi!($($rest)*);
+ );
+}
+
+ffi! {
+ #[repr(C)]
+ pub struct STACKFRAME64 {
+ pub AddrPC: ADDRESS64,
+ pub AddrReturn: ADDRESS64,
+ pub AddrFrame: ADDRESS64,
+ pub AddrStack: ADDRESS64,
+ pub AddrBStore: ADDRESS64,
+ pub FuncTableEntry: PVOID,
+ pub Params: [DWORD64; 4],
+ pub Far: BOOL,
+ pub Virtual: BOOL,
+ pub Reserved: [DWORD64; 3],
+ pub KdHelp: KDHELP64,
+ }
+
+ pub type LPSTACKFRAME64 = *mut STACKFRAME64;
+
+ #[repr(C)]
+ pub struct STACKFRAME_EX {
+ pub AddrPC: ADDRESS64,
+ pub AddrReturn: ADDRESS64,
+ pub AddrFrame: ADDRESS64,
+ pub AddrStack: ADDRESS64,
+ pub AddrBStore: ADDRESS64,
+ pub FuncTableEntry: PVOID,
+ pub Params: [DWORD64; 4],
+ pub Far: BOOL,
+ pub Virtual: BOOL,
+ pub Reserved: [DWORD64; 3],
+ pub KdHelp: KDHELP64,
+ pub StackFrameSize: DWORD,
+ pub InlineFrameContext: DWORD,
+ }
+
+ pub type LPSTACKFRAME_EX = *mut STACKFRAME_EX;
+
+ #[repr(C)]
+ pub struct IMAGEHLP_LINEW64 {
+ pub SizeOfStruct: DWORD,
+ pub Key: PVOID,
+ pub LineNumber: DWORD,
+ pub FileName: PWSTR,
+ pub Address: DWORD64,
+ }
+
+ pub type PIMAGEHLP_LINEW64 = *mut IMAGEHLP_LINEW64;
+
+ #[repr(C)]
+ pub struct SYMBOL_INFOW {
+ pub SizeOfStruct: ULONG,
+ pub TypeIndex: ULONG,
+ pub Reserved: [ULONG64; 2],
+ pub Index: ULONG,
+ pub Size: ULONG,
+ pub ModBase: ULONG64,
+ pub Flags: ULONG,
+ pub Value: ULONG64,
+ pub Address: ULONG64,
+ pub Register: ULONG,
+ pub Scope: ULONG,
+ pub Tag: ULONG,
+ pub NameLen: ULONG,
+ pub MaxNameLen: ULONG,
+ pub Name: [WCHAR; 1],
+ }
+
+ pub type PSYMBOL_INFOW = *mut SYMBOL_INFOW;
+
+ pub type PTRANSLATE_ADDRESS_ROUTINE64 = Option<
+ unsafe extern "system" fn(hProcess: HANDLE, hThread: HANDLE, lpaddr: LPADDRESS64) -> DWORD64,
+ >;
+ pub type PGET_MODULE_BASE_ROUTINE64 =
+ Option<unsafe extern "system" fn(hProcess: HANDLE, Address: DWORD64) -> DWORD64>;
+ pub type PFUNCTION_TABLE_ACCESS_ROUTINE64 =
+ Option<unsafe extern "system" fn(ahProcess: HANDLE, AddrBase: DWORD64) -> PVOID>;
+ pub type PREAD_PROCESS_MEMORY_ROUTINE64 = Option<
+ unsafe extern "system" fn(
+ hProcess: HANDLE,
+ qwBaseAddress: DWORD64,
+ lpBuffer: PVOID,
+ nSize: DWORD,
+ lpNumberOfBytesRead: LPDWORD,
+ ) -> BOOL,
+ >;
+
+ #[repr(C)]
+ pub struct ADDRESS64 {
+ pub Offset: DWORD64,
+ pub Segment: WORD,
+ pub Mode: ADDRESS_MODE,
+ }
+
+ pub type LPADDRESS64 = *mut ADDRESS64;
+
+ pub type ADDRESS_MODE = u32;
+
+ #[repr(C)]
+ pub struct KDHELP64 {
+ pub Thread: DWORD64,
+ pub ThCallbackStack: DWORD,
+ pub ThCallbackBStore: DWORD,
+ pub NextCallback: DWORD,
+ pub FramePointer: DWORD,
+ pub KiCallUserMode: DWORD64,
+ pub KeUserCallbackDispatcher: DWORD64,
+ pub SystemRangeStart: DWORD64,
+ pub KiUserExceptionDispatcher: DWORD64,
+ pub StackBase: DWORD64,
+ pub StackLimit: DWORD64,
+ pub BuildVersion: DWORD,
+ pub Reserved0: DWORD,
+ pub Reserved1: [DWORD64; 4],
+ }
+
+ #[repr(C)]
+ pub struct MODULEENTRY32W {
+ pub dwSize: DWORD,
+ pub th32ModuleID: DWORD,
+ pub th32ProcessID: DWORD,
+ pub GlblcntUsage: DWORD,
+ pub ProccntUsage: DWORD,
+ pub modBaseAddr: *mut u8,
+ pub modBaseSize: DWORD,
+ pub hModule: HMODULE,
+ pub szModule: [WCHAR; MAX_MODULE_NAME32 + 1],
+ pub szExePath: [WCHAR; MAX_PATH],
+ }
+
+ pub const MAX_SYM_NAME: usize = 2000;
+ pub const AddrModeFlat: ADDRESS_MODE = 3;
+ pub const TRUE: BOOL = 1;
+ pub const FALSE: BOOL = 0;
+ pub const PROCESS_QUERY_INFORMATION: DWORD = 0x400;
+ pub const IMAGE_FILE_MACHINE_ARM64: u16 = 43620;
+ pub const IMAGE_FILE_MACHINE_AMD64: u16 = 34404;
+ pub const IMAGE_FILE_MACHINE_I386: u16 = 332;
+ pub const IMAGE_FILE_MACHINE_ARMNT: u16 = 452;
+ pub const FILE_SHARE_READ: DWORD = 0x1;
+ pub const FILE_SHARE_WRITE: DWORD = 0x2;
+ pub const OPEN_EXISTING: DWORD = 0x3;
+ pub const GENERIC_READ: DWORD = 0x80000000;
+ pub const INFINITE: DWORD = !0;
+ pub const PAGE_READONLY: DWORD = 2;
+ pub const FILE_MAP_READ: DWORD = 4;
+ pub const TH32CS_SNAPMODULE: DWORD = 0x00000008;
+ pub const INVALID_HANDLE_VALUE: HANDLE = -1isize as HANDLE;
+ pub const MAX_MODULE_NAME32: usize = 255;
+ pub const MAX_PATH: usize = 260;
+
+ pub type DWORD = u32;
+ pub type PDWORD = *mut u32;
+ pub type BOOL = i32;
+ pub type DWORD64 = u64;
+ pub type PDWORD64 = *mut u64;
+ pub type HANDLE = *mut c_void;
+ pub type PVOID = HANDLE;
+ pub type PCWSTR = *const u16;
+ pub type LPSTR = *mut i8;
+ pub type LPCSTR = *const i8;
+ pub type PWSTR = *mut u16;
+ pub type WORD = u16;
+ pub type ULONG = u32;
+ pub type ULONG64 = u64;
+ pub type WCHAR = u16;
+ pub type PCONTEXT = *mut CONTEXT;
+ pub type LPDWORD = *mut DWORD;
+ pub type DWORDLONG = u64;
+ pub type HMODULE = HINSTANCE;
+ pub type SIZE_T = usize;
+ pub type LPVOID = *mut c_void;
+ pub type LPCVOID = *const c_void;
+ pub type LPMODULEENTRY32W = *mut MODULEENTRY32W;
+
+ extern "system" {
+ pub fn GetCurrentProcess() -> HANDLE;
+ pub fn GetCurrentThread() -> HANDLE;
+ pub fn RtlCaptureContext(ContextRecord: PCONTEXT) -> ();
+ pub fn LoadLibraryA(a: *const i8) -> HMODULE;
+ pub fn GetProcAddress(h: HMODULE, name: *const i8) -> FARPROC;
+ pub fn GetModuleHandleA(name: *const i8) -> HMODULE;
+ pub fn OpenProcess(
+ dwDesiredAccess: DWORD,
+ bInheitHandle: BOOL,
+ dwProcessId: DWORD,
+ ) -> HANDLE;
+ pub fn GetCurrentProcessId() -> DWORD;
+ pub fn CloseHandle(h: HANDLE) -> BOOL;
+ pub fn CreateFileA(
+ lpFileName: LPCSTR,
+ dwDesiredAccess: DWORD,
+ dwShareMode: DWORD,
+ lpSecurityAttributes: LPSECURITY_ATTRIBUTES,
+ dwCreationDisposition: DWORD,
+ dwFlagsAndAttributes: DWORD,
+ hTemplateFile: HANDLE,
+ ) -> HANDLE;
+ pub fn CreateMutexA(
+ attrs: LPSECURITY_ATTRIBUTES,
+ initial: BOOL,
+ name: LPCSTR,
+ ) -> HANDLE;
+ pub fn ReleaseMutex(hMutex: HANDLE) -> BOOL;
+ pub fn WaitForSingleObjectEx(
+ hHandle: HANDLE,
+ dwMilliseconds: DWORD,
+ bAlertable: BOOL,
+ ) -> DWORD;
+ pub fn CreateFileMappingA(
+ hFile: HANDLE,
+ lpFileMappingAttributes: LPSECURITY_ATTRIBUTES,
+ flProtect: DWORD,
+ dwMaximumSizeHigh: DWORD,
+ dwMaximumSizeLow: DWORD,
+ lpName: LPCSTR,
+ ) -> HANDLE;
+ pub fn MapViewOfFile(
+ hFileMappingObject: HANDLE,
+ dwDesiredAccess: DWORD,
+ dwFileOffsetHigh: DWORD,
+ dwFileOffsetLow: DWORD,
+ dwNumberOfBytesToMap: SIZE_T,
+ ) -> LPVOID;
+ pub fn UnmapViewOfFile(lpBaseAddress: LPCVOID) -> BOOL;
+ pub fn CreateToolhelp32Snapshot(
+ dwFlags: DWORD,
+ th32ProcessID: DWORD,
+ ) -> HANDLE;
+ pub fn Module32FirstW(
+ hSnapshot: HANDLE,
+ lpme: LPMODULEENTRY32W,
+ ) -> BOOL;
+ pub fn Module32NextW(
+ hSnapshot: HANDLE,
+ lpme: LPMODULEENTRY32W,
+ ) -> BOOL;
+ }
+}
+
+#[cfg(target_pointer_width = "64")]
+ffi! {
+ extern "system" {
+ pub fn RtlLookupFunctionEntry(
+ ControlPc: DWORD64,
+ ImageBase: PDWORD64,
+ HistoryTable: PUNWIND_HISTORY_TABLE,
+ ) -> PRUNTIME_FUNCTION;
+ }
+}
+
+#[cfg(target_arch = "aarch64")]
+ffi! {
+ #[repr(C, align(16))]
+ pub struct CONTEXT {
+ pub ContextFlags: DWORD,
+ pub Cpsr: DWORD,
+ pub u: CONTEXT_u,
+ pub Sp: u64,
+ pub Pc: u64,
+ pub V: [ARM64_NT_NEON128; 32],
+ pub Fpcr: DWORD,
+ pub Fpsr: DWORD,
+ pub Bcr: [DWORD; ARM64_MAX_BREAKPOINTS],
+ pub Bvr: [DWORD64; ARM64_MAX_BREAKPOINTS],
+ pub Wcr: [DWORD; ARM64_MAX_WATCHPOINTS],
+ pub Wvr: [DWORD64; ARM64_MAX_WATCHPOINTS],
+ }
+
+ #[repr(C)]
+ pub struct CONTEXT_u {
+ pub s: CONTEXT_u_s,
+ }
+
+ impl CONTEXT_u {
+ pub unsafe fn s(&self) -> &CONTEXT_u_s {
+ &self.s
+ }
+ }
+
+ #[repr(C)]
+ pub struct CONTEXT_u_s {
+ pub X0: u64,
+ pub X1: u64,
+ pub X2: u64,
+ pub X3: u64,
+ pub X4: u64,
+ pub X5: u64,
+ pub X6: u64,
+ pub X7: u64,
+ pub X8: u64,
+ pub X9: u64,
+ pub X10: u64,
+ pub X11: u64,
+ pub X12: u64,
+ pub X13: u64,
+ pub X14: u64,
+ pub X15: u64,
+ pub X16: u64,
+ pub X17: u64,
+ pub X18: u64,
+ pub X19: u64,
+ pub X20: u64,
+ pub X21: u64,
+ pub X22: u64,
+ pub X23: u64,
+ pub X24: u64,
+ pub X25: u64,
+ pub X26: u64,
+ pub X27: u64,
+ pub X28: u64,
+ pub Fp: u64,
+ pub Lr: u64,
+ }
+
+ pub const ARM64_MAX_BREAKPOINTS: usize = 8;
+ pub const ARM64_MAX_WATCHPOINTS: usize = 2;
+
+ #[repr(C)]
+ pub struct ARM64_NT_NEON128 {
+ pub D: [f64; 2],
+ }
+}
+
+#[cfg(target_arch = "x86")]
+ffi! {
+ #[repr(C)]
+ pub struct CONTEXT {
+ pub ContextFlags: DWORD,
+ pub Dr0: DWORD,
+ pub Dr1: DWORD,
+ pub Dr2: DWORD,
+ pub Dr3: DWORD,
+ pub Dr6: DWORD,
+ pub Dr7: DWORD,
+ pub FloatSave: FLOATING_SAVE_AREA,
+ pub SegGs: DWORD,
+ pub SegFs: DWORD,
+ pub SegEs: DWORD,
+ pub SegDs: DWORD,
+ pub Edi: DWORD,
+ pub Esi: DWORD,
+ pub Ebx: DWORD,
+ pub Edx: DWORD,
+ pub Ecx: DWORD,
+ pub Eax: DWORD,
+ pub Ebp: DWORD,
+ pub Eip: DWORD,
+ pub SegCs: DWORD,
+ pub EFlags: DWORD,
+ pub Esp: DWORD,
+ pub SegSs: DWORD,
+ pub ExtendedRegisters: [u8; 512],
+ }
+
+ #[repr(C)]
+ pub struct FLOATING_SAVE_AREA {
+ pub ControlWord: DWORD,
+ pub StatusWord: DWORD,
+ pub TagWord: DWORD,
+ pub ErrorOffset: DWORD,
+ pub ErrorSelector: DWORD,
+ pub DataOffset: DWORD,
+ pub DataSelector: DWORD,
+ pub RegisterArea: [u8; 80],
+ pub Spare0: DWORD,
+ }
+}
+
+#[cfg(target_arch = "x86_64")]
+ffi! {
+ #[repr(C, align(8))]
+ pub struct CONTEXT {
+ pub P1Home: DWORDLONG,
+ pub P2Home: DWORDLONG,
+ pub P3Home: DWORDLONG,
+ pub P4Home: DWORDLONG,
+ pub P5Home: DWORDLONG,
+ pub P6Home: DWORDLONG,
+
+ pub ContextFlags: DWORD,
+ pub MxCsr: DWORD,
+
+ pub SegCs: WORD,
+ pub SegDs: WORD,
+ pub SegEs: WORD,
+ pub SegFs: WORD,
+ pub SegGs: WORD,
+ pub SegSs: WORD,
+ pub EFlags: DWORD,
+
+ pub Dr0: DWORDLONG,
+ pub Dr1: DWORDLONG,
+ pub Dr2: DWORDLONG,
+ pub Dr3: DWORDLONG,
+ pub Dr6: DWORDLONG,
+ pub Dr7: DWORDLONG,
+
+ pub Rax: DWORDLONG,
+ pub Rcx: DWORDLONG,
+ pub Rdx: DWORDLONG,
+ pub Rbx: DWORDLONG,
+ pub Rsp: DWORDLONG,
+ pub Rbp: DWORDLONG,
+ pub Rsi: DWORDLONG,
+ pub Rdi: DWORDLONG,
+ pub R8: DWORDLONG,
+ pub R9: DWORDLONG,
+ pub R10: DWORDLONG,
+ pub R11: DWORDLONG,
+ pub R12: DWORDLONG,
+ pub R13: DWORDLONG,
+ pub R14: DWORDLONG,
+ pub R15: DWORDLONG,
+
+ pub Rip: DWORDLONG,
+
+ pub FltSave: FLOATING_SAVE_AREA,
+
+ pub VectorRegister: [M128A; 26],
+ pub VectorControl: DWORDLONG,
+
+ pub DebugControl: DWORDLONG,
+ pub LastBranchToRip: DWORDLONG,
+ pub LastBranchFromRip: DWORDLONG,
+ pub LastExceptionToRip: DWORDLONG,
+ pub LastExceptionFromRip: DWORDLONG,
+ }
+
+ #[repr(C)]
+ pub struct M128A {
+ pub Low: u64,
+ pub High: i64,
+ }
+}
+
+#[repr(C)]
+#[cfg(target_arch = "x86_64")]
+#[derive(Copy, Clone)]
+pub struct FLOATING_SAVE_AREA {
+ _Dummy: [u8; 512],
+}
+
+#[cfg(target_arch = "arm")]
+ffi! {
+ // #[repr(C)]
+ // pub struct NEON128 {
+ // pub Low: ULONG64,
+ // pub High: LONG64,
+ // }
+
+ // pub type PNEON128 = *mut NEON128;
+
+ #[repr(C)]
+ pub struct CONTEXT_u {
+ // pub Q: [NEON128; 16],
+ pub D: [ULONG64; 32],
+ // pub S: [DWORD; 32],
+ }
+
+ pub const ARM_MAX_BREAKPOINTS: usize = 8;
+ pub const ARM_MAX_WATCHPOINTS: usize = 1;
+
+ #[repr(C)]
+ pub struct CONTEXT {
+ pub ContextFlags: DWORD,
+ pub R0: DWORD,
+ pub R1: DWORD,
+ pub R2: DWORD,
+ pub R3: DWORD,
+ pub R4: DWORD,
+ pub R5: DWORD,
+ pub R6: DWORD,
+ pub R7: DWORD,
+ pub R8: DWORD,
+ pub R9: DWORD,
+ pub R10: DWORD,
+ pub R11: DWORD,
+ pub R12: DWORD,
+ pub Sp: DWORD,
+ pub Lr: DWORD,
+ pub Pc: DWORD,
+ pub Cpsr: DWORD,
+ pub Fpsrc: DWORD,
+ pub Padding: DWORD,
+ pub u: CONTEXT_u,
+ pub Bvr: [DWORD; ARM_MAX_BREAKPOINTS],
+ pub Bcr: [DWORD; ARM_MAX_BREAKPOINTS],
+ pub Wvr: [DWORD; ARM_MAX_WATCHPOINTS],
+ pub Wcr: [DWORD; ARM_MAX_WATCHPOINTS],
+ pub Padding2: [DWORD; 2],
+ }
+} // IFDEF(arm)