1 // Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
15 use sys_common::mutex::Mutex;
17 use super::super::printing::print;
20 #[inline(never)] // if we know this is a function call, we can skip it when
22 pub fn write(w: &mut Write) -> io::Result<()> {
25 writer: &'a mut (Write+'a),
26 last_error: Option<io::Error>,
29 // When using libbacktrace, we use some necessary global state, so we
30 // need to prevent more than one thread from entering this block. This
31 // is semi-reasonable in terms of printing anyway, and we know that all
32 // I/O done here is blocking I/O, not green I/O, so we don't have to
33 // worry about this being a native vs green mutex.
34 static LOCK: Mutex = Mutex::new();
38 writeln!(w, "stack backtrace:")?;
40 let mut cx = Context { writer: w, last_error: None, idx: 0 };
42 uw::_Unwind_Backtrace(trace_fn,
43 &mut cx as *mut Context as *mut libc::c_void)
45 uw::_URC_NO_REASON => {
47 Some(err) => Err(err),
57 extern fn trace_fn(ctx: *mut uw::_Unwind_Context,
58 arg: *mut libc::c_void) -> uw::_Unwind_Reason_Code {
59 let cx: &mut Context = unsafe { mem::transmute(arg) };
60 let mut ip_before_insn = 0;
62 uw::_Unwind_GetIPInfo(ctx, &mut ip_before_insn) as *mut libc::c_void
64 if !ip.is_null() && ip_before_insn == 0 {
65 // this is a non-signaling frame, so `ip` refers to the address
66 // after the calling instruction. account for that.
67 ip = (ip as usize - 1) as *mut _;
70 // dladdr() on osx gets whiny when we use FindEnclosingFunction, and
71 // it appears to work fine without it, so we only use
72 // FindEnclosingFunction on non-osx platforms. In doing so, we get a
73 // slightly more accurate stack trace in the process.
75 // This is often because panic involves the last instruction of a
76 // function being "call std::rt::begin_unwind", with no ret
77 // instructions after it. This means that the return instruction
78 // pointer points *outside* of the calling function, and by
79 // unwinding it we go back to the original function.
80 let symaddr = if cfg!(target_os = "macos") || cfg!(target_os = "ios") {
83 unsafe { uw::_Unwind_FindEnclosingFunction(ip) }
86 // Don't print out the first few frames (they're not user frames)
88 if cx.idx <= 0 { return uw::_URC_NO_REASON }
89 // Don't print ginormous backtraces
91 match write!(cx.writer, " ... <frames omitted>\n") {
93 Err(e) => { cx.last_error = Some(e); }
95 return uw::_URC_FAILURE
98 // Once we hit an error, stop trying to print more frames
99 if cx.last_error.is_some() { return uw::_URC_FAILURE }
101 match print(cx.writer, cx.idx, ip, symaddr) {
103 Err(e) => { cx.last_error = Some(e); }