Ignore panic related functions, functions before main and thread entry points in backtraces

Author: Zoxc

src/libcore/panicking.rs

@@ -48,25 +48,38 @@ pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
     // Arguments::new_v1 may allow the compiler to omit Formatter::pad from the
     // output binary, saving up to a few kilobytes.
     let (expr, file, line, col) = *expr_file_line_col;
-    panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col))
+    panic_dispatch(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col), &(panic as usize))
 }
 
 #[cold] #[inline(never)]
 #[lang = "panic_bounds_check"]
 fn panic_bounds_check(file_line_col: &(&'static str, u32, u32),
-                     index: usize, len: usize) -> ! {
-    panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}",
-                           len, index), file_line_col)
+                      index: usize, len: usize) -> ! {
+    panic_dispatch(format_args!("index out of bounds: the len is {} but the index is {}",
+                                len, index),
+                   file_line_col,
+                   &(panic_bounds_check as usize))
 }
 
 #[cold] #[inline(never)]
 pub fn panic_fmt(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {
+    panic_dispatch(fmt, file_line_col, &(panic_fmt as usize));
+}
+
+#[cold]
+fn panic_dispatch(fmt: fmt::Arguments,
+                 file_line_col: &(&'static str, u32, u32),
+                 entry_point: &usize) -> ! {
     #[allow(improper_ctypes)]
     extern {
         #[lang = "panic_fmt"]
         #[unwind]
-        fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: u32, col: u32) -> !;
+        fn panic_impl(fmt: fmt::Arguments,
+                      file: &'static str,
+                      line: u32,
+                      col: u32,
+                      entry_point: &usize) -> !;
     }
     let (file, line, col) = *file_line_col;
-    unsafe { panic_impl(fmt, file, line, col) }
-}
+    unsafe { panic_impl(fmt, file, line, col, entry_point) }
+}

src/libstd/panicking.rs

@@ -181,6 +181,7 @@ pub fn take_hook() -> Box<Fn(&PanicInfo) + 'static + Sync + Send> {
 pub struct PanicInfo<'a> {
     payload: &'a (Any + Send),
     location: Location<'a>,
+    entry_point: usize,
 }
 
 impl<'a> PanicInfo<'a> {
@@ -378,7 +379,7 @@ fn default_hook(info: &PanicInfo) {
             static FIRST_PANIC: AtomicBool = AtomicBool::new(true);
 
             if let Some(format) = log_backtrace {
-                let _ = backtrace::print(err, format);
+                let _ = backtrace::print(err, format, info.entry_point);
             } else if FIRST_PANIC.compare_and_swap(true, false, Ordering::SeqCst) {
                 let _ = writeln!(err, "note: Run with `RUST_BACKTRACE=1` for a backtrace.");
             }
@@ -494,8 +495,9 @@ pub fn panicking() -> bool {
 pub extern fn rust_begin_panic(msg: fmt::Arguments,
                                file: &'static str,
                                line: u32,
-                               col: u32) -> ! {
-    begin_panic_fmt(&msg, &(file, line, col))
+                               col: u32,
+                               entry_point: &usize) -> ! {
+    rust_panic_fmt(&msg, &(file, line, col), entry_point)
 }
 
 /// The entry point for panicking with a formatted message.
@@ -508,8 +510,14 @@ pub extern fn rust_begin_panic(msg: fmt::Arguments,
            reason = "used by the panic! macro",
            issue = "0")]
 #[inline(never)] #[cold]
-pub fn begin_panic_fmt(msg: &fmt::Arguments,
-                       file_line_col: &(&'static str, u32, u32)) -> ! {
+pub fn begin_panic_fmt(msg: &fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {
+    rust_panic_fmt(msg, file_line_col, &(begin_panic_fmt as usize))
+}
+
+#[cold]
+fn rust_panic_fmt(msg: &fmt::Arguments,
+                  file_line_col: &(&'static str, u32, u32),
+                  entry_point: &usize) -> ! {
     use fmt::Write;
 
     // We do two allocations here, unfortunately. But (a) they're
@@ -519,7 +527,7 @@ pub fn begin_panic_fmt(msg: &fmt::Arguments,
 
     let mut s = String::new();
     let _ = s.write_fmt(*msg);
-    begin_panic(s, file_line_col)
+    rust_panic_with_hook(Box::new(s), file_line_col, entry_point)
 }
 
 /// This is the entry point of panicking for panic!() and assert!().
@@ -535,7 +543,7 @@ pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u3
     // be performed in the parent of this thread instead of the thread that's
     // panicking.
 
-    rust_panic_with_hook(Box::new(msg), file_line_col)
+    rust_panic_with_hook(Box::new(msg), file_line_col, &(begin_panic::<M> as usize))
 }
 
 /// Executes the primary logic for a panic, including checking for recursive
@@ -546,8 +554,9 @@ pub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u3
 /// run panic hooks, and then delegate to the actual implementation of panics.
 #[inline(never)]
 #[cold]
-fn rust_panic_with_hook(msg: Box<Any + Send>,
-                        file_line_col: &(&'static str, u32, u32)) -> ! {
+pub(crate) fn rust_panic_with_hook(msg: Box<Any + Send>,
+                                   file_line_col: &(&'static str, u32, u32),
+                                   entry_point: &usize) -> ! {
     let (file, line, col) = *file_line_col;
 
     let panics = update_panic_count(1);
@@ -571,6 +580,7 @@ fn rust_panic_with_hook(msg: Box<Any + Send>,
                 line,
                 col,
             },
+            entry_point: *entry_point,
         };
         HOOK_LOCK.read();
         match HOOK {

src/libstd/rt.rs

@@ -56,7 +56,8 @@ fn lang_start(main: fn(), argc: isize, argv: *const *const u8) -> isize {
         // Let's run some code!
         #[cfg(feature = "backtrace")]
         let res = panic::catch_unwind(|| {
-            ::sys_common::backtrace::__rust_begin_short_backtrace(main)
+            let mut main = main;
+            ::sys_common::backtrace::mark_start(&mut main)
         });
         #[cfg(not(feature = "backtrace"))]
         let res = panic::catch_unwind(mem::transmute::<_, fn()>(main));

src/libstd/sys/unix/backtrace/printing/dladdr.rs

@@ -18,17 +18,17 @@ use sys_common::backtrace::Frame;
 pub fn resolve_symname<F>(frame: Frame,
                           callback: F,
                           _: &BacktraceContext) -> io::Result<()>
-    where F: FnOnce(Option<&str>) -> io::Result<()>
+    where F: FnOnce(Option<(&str, usize)>) -> io::Result<()>
 {
     unsafe {
         let mut info: Dl_info = intrinsics::init();
-        let symname = if dladdr(frame.exact_position as *mut _, &mut info) == 0 ||
+        let symninfo = if dladdr(frame.exact_position as *mut _, &mut info) == 0 ||
                          info.dli_sname.is_null() {
             None
         } else {
-            CStr::from_ptr(info.dli_sname).to_str().ok()
+            CStr::from_ptr(info.dli_sname).to_str().ok().map(|s| (s, info.dli_saddr as usize))
         };
-        callback(symname)
+        callback(syminfo)
     }
 }
 

src/libstd/sys/unix/backtrace/printing/mod.rs

@@ -31,11 +31,11 @@ pub use sys_common::gnu::libbacktrace::foreach_symbol_fileline;
 #[cfg(not(target_os = "emscripten"))]
 pub fn resolve_symname<F>(frame: Frame, callback: F, bc: &BacktraceContext) -> io::Result<()>
 where
-    F: FnOnce(Option<&str>) -> io::Result<()>
+    F: FnOnce(Option<(&str, usize)>) -> io::Result<()>
 {
-    ::sys_common::gnu::libbacktrace::resolve_symname(frame, |symname| {
-        if symname.is_some() {
-            callback(symname)
+    ::sys_common::gnu::libbacktrace::resolve_symname(frame, |syminfo| {
+        if syminfo.is_some() {
+            callback(syminfo)
         } else {
             dladdr::resolve_symname(frame, callback, bc)
         }

src/libstd/sys/windows/backtrace/printing/msvc.rs

@@ -27,7 +27,7 @@ type SymGetLineFromAddr64Fn =
 pub fn resolve_symname<F>(frame: Frame,
                           callback: F,
                           context: &BacktraceContext) -> io::Result<()>
-    where F: FnOnce(Option<&str>) -> io::Result<()>
+    where F: FnOnce(Option<(&str, usize)>) -> io::Result<()>
 {
     let SymFromAddr = sym!(&context.dbghelp, "SymFromAddr", SymFromAddrFn)?;
 
@@ -45,13 +45,15 @@ pub fn resolve_symname<F>(frame: Frame,
                               &mut displacement,
                               &mut info);
 
-        let symname = if ret == c::TRUE {
+        let syminfo = if ret == c::TRUE {
             let ptr = info.Name.as_ptr() as *const c_char;
-            CStr::from_ptr(ptr).to_str().ok()
+            CStr::from_ptr(ptr).to_str().ok().map(|s| {
+                (s, (frame.symbol_addr as usize).wrapping_sub(displacement as usize))
+            })
         } else {
             None
         };
-        callback(symname)
+        callback(syminfo)
     }
 }
 

src/libstd/sys_common/backtrace.rs

@@ -47,27 +47,27 @@ pub struct Frame {
 const MAX_NB_FRAMES: usize = 100;
 
 /// Prints the current backtrace.
-pub fn print(w: &mut Write, format: PrintFormat) -> io::Result<()> {
+pub fn print(w: &mut Write, format: PrintFormat, entry_point: usize) -> io::Result<()> {
     static LOCK: Mutex = Mutex::new();
 
     // Use a lock to prevent mixed output in multithreading context.
     // Some platforms also requires it, like `SymFromAddr` on Windows.
     unsafe {
         LOCK.lock();
-        let res = _print(w, format);
+        let res = _print(w, format, entry_point);
         LOCK.unlock();
         res
     }
 }
 
-fn _print(w: &mut Write, format: PrintFormat) -> io::Result<()> {
+fn _print(w: &mut Write, format: PrintFormat, entry_point: usize) -> io::Result<()> {
     let mut frames = [Frame {
         exact_position: ptr::null(),
         symbol_addr: ptr::null(),
     }; MAX_NB_FRAMES];
     let (nb_frames, context) = unwind_backtrace(&mut frames)?;
     let (skipped_before, skipped_after) =
-        filter_frames(&frames[..nb_frames], format, &context);
+        filter_frames(&frames[..nb_frames], format, &context, entry_point);
     if skipped_before + skipped_after > 0 {
         writeln!(w, "note: Some details are omitted, \
                      run with `RUST_BACKTRACE=full` for a verbose backtrace.")?;
@@ -76,8 +76,8 @@ fn _print(w: &mut Write, format: PrintFormat) -> io::Result<()> {
 
     let filtered_frames = &frames[..nb_frames - skipped_after];
     for (index, frame) in filtered_frames.iter().skip(skipped_before).enumerate() {
-        resolve_symname(*frame, |symname| {
-            output(w, index, *frame, symname, format)
+        resolve_symname(*frame, |syminfo| {
+            output(w, index, *frame, syminfo.map(|i| i.0), format)
         }, &context)?;
         let has_more_filenames = foreach_symbol_fileline(*frame, |file, line| {
             output_fileline(w, file, line, format)
@@ -94,27 +94,32 @@ fn _print(w: &mut Write, format: PrintFormat) -> io::Result<()> {
 /// backtrace, according to the backtrace format.
 fn filter_frames(frames: &[Frame],
                  format: PrintFormat,
-                 context: &BacktraceContext) -> (usize, usize)
+                 context: &BacktraceContext,
+                 entry_point: usize) -> (usize, usize)
 {
     if format == PrintFormat::Full {
         return (0, 0);
     }
 
-    let skipped_before = 0;
+    let skipped_before = frames.iter().position(|frame| {
+        let mut addr = None;
+        let _ = resolve_symname(*frame, |syminfo| {
+            addr = syminfo.map(|a| a.1);
+            Ok(())
+        }, context);
+        addr == Some(entry_point)
+    }).map(|p| p + 1).unwrap_or(0);
 
-    let skipped_after = frames.len() - frames.iter().position(|frame| {
+    let skipped_after = frames.iter().rev().position(|frame| {
         let mut is_marker = false;
-        let _ = resolve_symname(*frame, |symname| {
-            if let Some(mangled_symbol_name) = symname {
-                // Use grep to find the concerned functions
-                if mangled_symbol_name.contains("__rust_begin_short_backtrace") {
-                    is_marker = true;
-                }
+        let _ = resolve_symname(*frame, |syminfo| {
+            if syminfo.map(|i| i.1) == Some(MARK_START.0 as usize) {
+                is_marker = true;
             }
             Ok(())
         }, context);
         is_marker
-    }).unwrap_or(frames.len());
+    }).map(|p| p + 1).unwrap_or(0);
 
     if skipped_before + skipped_after >= frames.len() {
         // Avoid showing completely empty backtraces
@@ -124,13 +129,19 @@ fn filter_frames(frames: &[Frame],
     (skipped_before, skipped_after)
 }
 
+#[derive(Eq, PartialEq)]
+struct Function(*const ());
+unsafe impl Sync for Function {}
+
+static MARK_START: Function = Function(mark_start as *const ());
 
-/// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`.
+/// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`
 #[inline(never)]
-pub fn __rust_begin_short_backtrace<F, T>(f: F) -> T
-    where F: FnOnce() -> T, F: Send + 'static, T: Send + 'static
-{
-    f()
+pub fn mark_start(f: &mut FnMut()) {
+    f();
+    unsafe {
+        asm!("" ::: "memory" : "volatile"); // A dummy statement to prevent tail call optimization
+    }
 }
 
 /// Controls how the backtrace should be formated.

src/libstd/sys_common/gnu/libbacktrace.rs

@@ -63,34 +63,34 @@ where F: FnMut(&[u8], u32) -> io::Result<()>
 pub fn resolve_symname<F>(frame: Frame,
                           callback: F,
                           _: &BacktraceContext) -> io::Result<()>
-    where F: FnOnce(Option<&str>) -> io::Result<()>
+    where F: FnOnce(Option<(&str, usize)>) -> io::Result<()>
 {
-    let symname = {
+    let syminfo = {
         let state = unsafe { init_state() };
         if state.is_null() {
             return Err(io::Error::new(
                 io::ErrorKind::Other,
                 "failed to allocate libbacktrace state")
             )
         }
-        let mut data = ptr::null();
-        let data_addr = &mut data as *mut *const libc::c_char;
+        let mut data = (ptr::null(), 0);
+        let data_addr = &mut data as *mut _;
         let ret = unsafe {
             backtrace_syminfo(state,
                               frame.symbol_addr as libc::uintptr_t,
                               syminfo_cb,
                               error_cb,
                               data_addr as *mut libc::c_void)
         };
-        if ret == 0 || data.is_null() {
+        if ret == 0 || data.0.is_null() {
             None
         } else {
             unsafe {
-                CStr::from_ptr(data).to_str().ok()
+                CStr::from_ptr(data.0).to_str().ok().map(|s| (s, data.1))
             }
         }
     };
-    callback(symname)
+    callback(syminfo)
 }
 
 ////////////////////////////////////////////////////////////////////////
@@ -145,10 +145,10 @@ extern fn error_cb(_data: *mut libc::c_void, _msg: *const libc::c_char,
 extern fn syminfo_cb(data: *mut libc::c_void,
                      _pc: libc::uintptr_t,
                      symname: *const libc::c_char,
-                     _symval: libc::uintptr_t,
+                     symval: libc::uintptr_t,
                      _symsize: libc::uintptr_t) {
-    let slot = data as *mut *const libc::c_char;
-    unsafe { *slot = symname; }
+    let slot = data as *mut (*const libc::c_char, usize);
+    unsafe { *slot = (symname, symval); }
 }
 extern fn pcinfo_cb(data: *mut libc::c_void,
                     _pc: libc::uintptr_t,

src/libstd/thread/mod.rs

@@ -403,7 +403,13 @@ impl Builder {
                 thread_info::set(imp::guard::current(), their_thread);
                 #[cfg(feature = "backtrace")]
                 let try_result = panic::catch_unwind(panic::AssertUnwindSafe(|| {
-                    ::sys_common::backtrace::__rust_begin_short_backtrace(f)
+                    let mut f = Some(f);
+                    let mut r = None;
+                    ::sys_common::backtrace::mark_start(&mut || {
+                        let f = f.take().unwrap();
+                        r = Some(f());
+                    });
+                    r.unwrap()
                 }));
                 #[cfg(not(feature = "backtrace"))]
                 let try_result = panic::catch_unwind(panic::AssertUnwindSafe(f));