src/libstd/sys/unix/backtrace/tracing/gcc_s.rs

   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.
   4 //
   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.
  10
  11 use io;
  12 use io::prelude::*;
  13 use libc;
  14 use mem;
  15 use sys_common::mutex::Mutex;
  16
  17 use super::super::printing::print;
  18 use unwind as uw;
  19
  20 #[inline(never)] // if we know this is a function call, we can skip it when
  21                  // tracing
  22 pub fn write(w: &mut Write) -> io::Result<()> {
  23     struct Context<'a> {
  24         idx: isize,
  25         writer: &'a mut (Write+'a),
  26         last_error: Option<io::Error>,
  27     }
  28
  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();
  35     unsafe {
  36         LOCK.lock();
  37
  38         writeln!(w, "stack backtrace:")?;
  39
  40         let mut cx = Context { writer: w, last_error: None, idx: 0 };
  41         let ret = match {
  42             uw::_Unwind_Backtrace(trace_fn,
  43                                   &mut cx as *mut Context as *mut libc::c_void)
  44         } {
  45             uw::_URC_NO_REASON => {
  46                 match cx.last_error {
  47                     Some(err) => Err(err),
  48                     None => Ok(())
  49                 }
  50             }
  51             _ => Ok(()),
  52         };
  53         LOCK.unlock();
  54         return ret
  55     }
  56
  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;
  61         let mut ip = unsafe {
  62             uw::_Unwind_GetIPInfo(ctx, &mut ip_before_insn) as *mut libc::c_void
  63         };
  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 _;
  68         }
  69
  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.
  74         //
  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") {
  81             ip
  82         } else {
  83             unsafe { uw::_Unwind_FindEnclosingFunction(ip) }
  84         };
  85
  86         // Don't print out the first few frames (they're not user frames)
  87         cx.idx += 1;
  88         if cx.idx <= 0 { return uw::_URC_NO_REASON }
  89         // Don't print ginormous backtraces
  90         if cx.idx > 100 {
  91             match write!(cx.writer, " ... <frames omitted>\n") {
  92                 Ok(()) => {}
  93                 Err(e) => { cx.last_error = Some(e); }
  94             }
  95             return uw::_URC_FAILURE
  96         }
  97
  98         // Once we hit an error, stop trying to print more frames
  99         if cx.last_error.is_some() { return uw::_URC_FAILURE }
 100
 101         match print(cx.writer, cx.idx, ip, symaddr) {
 102             Ok(()) => {}
 103             Err(e) => { cx.last_error = Some(e); }
 104         }
 105
 106         // keep going
 107         uw::_URC_NO_REASON
 108     }
 109 }