Ignore panic related functions in backtraces. Also fixes __rust_begin_short_backtrace

Author: Zoxc

src/libcore/panicking.rs

@@ -53,7 +53,7 @@ pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
 
 #[cold] #[inline(never)]
 #[lang = "panic_bounds_check"]
-fn panic_bounds_check(file_line_col: &(&'static str, u32, u32),
+pub 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)

src/libstd/lib.rs

@@ -265,6 +265,7 @@
 #![feature(const_ptr_null_mut)]
 #![feature(core_float)]
 #![feature(core_intrinsics)]
+#![feature(core_panic)]
 #![feature(dropck_eyepatch)]
 #![feature(exact_size_is_empty)]
 #![feature(float_from_str_radix)]

src/libstd/macros.rs

@@ -58,6 +58,28 @@
 /// panic!(4); // panic with the value of 4 to be collected elsewhere
 /// panic!("this is a {} {message}", "fancy", message = "message");
 /// ```
+#[cfg(not(stage0))]
+#[macro_export]
+#[stable(feature = "rust1", since = "1.0.0")]
+#[allow_internal_unstable]
+macro_rules! panic {
+    () => ({
+        panic!("explicit panic")
+    });
+    ($msg:str) => ({
+        $crate::rt::begin_panic_str(&($msg, file!(), line!(), __rust_unstable_column!()))
+    });
+    ($msg:expr) => ({
+        $crate::rt::begin_panic($msg, &(file!(), line!(), __rust_unstable_column!()))
+    });
+    ($fmt:expr, $($arg:tt)+) => ({
+        $crate::rt::begin_panic_fmt(&format_args!($fmt, $($arg)+),
+                                    &(file!(), line!(), __rust_unstable_column!()))
+    });
+}
+
+/// docs
+#[cfg(stage0)]
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow_internal_unstable]

src/libstd/panicking.rs

@@ -498,6 +498,16 @@ pub extern fn rust_begin_panic(msg: fmt::Arguments,
     begin_panic_fmt(&msg, &(file, line, col))
 }
 
+/// This is the entry point of panicking for string literals.
+#[unstable(feature = "libstd_sys_internals",
+           reason = "used by the panic! macro",
+           issue = "0")]
+#[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
+pub fn begin_panic_str(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {
+    let (expr, file, line, col) = *expr_file_line_col;
+    begin_panic(expr, &(file, line, col))
+}
+
 /// The entry point for panicking with a formatted message.
 ///
 /// This is designed to reduce the amount of code required at the call
@@ -535,6 +545,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.
 
+    // We want this call to get tail call optimized so `begin_panic` do not appear in backtraces
     rust_panic_with_hook(Box::new(msg), file_line_col)
 }
 
@@ -546,8 +557,8 @@ 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)) -> ! {
     let (file, line, col) = *file_line_col;
 
     let panics = update_panic_count(1);

src/libstd/rt.rs

@@ -25,7 +25,7 @@
 
 
 // Reexport some of our utilities which are expected by other crates.
-pub use panicking::{begin_panic, begin_panic_fmt, update_panic_count};
+pub use panicking::{begin_panic_str, begin_panic_fmt, begin_panic, update_panic_count};
 
 #[cfg(not(test))]
 #[lang = "start"]
@@ -57,7 +57,7 @@ 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)
+            ::sys_common::backtrace::__rust_begin_short_backtrace(main).0
         });
         #[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, &mut info) == 0 ||
+        let syminfo = if dladdr(frame.exact_position, &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, nfo.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| {
+    ::sys_common::gnu::libbacktrace::resolve_symname(frame, |syminfo| {
         if symname.is_some() {
-            callback(symname)
+            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

@@ -16,6 +16,8 @@ use io::prelude::*;
 use io;
 use libc;
 use str;
+use core;
+use panicking;
 use sync::atomic::{self, Ordering};
 use path::{self, Path};
 use sys::mutex::Mutex;
@@ -77,8 +79,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)
@@ -101,12 +103,32 @@ fn filter_frames(frames: &[Frame],
         return (0, 0);
     }
 
-    let skipped_before = 0;
+    #[derive(Eq, PartialEq)]
+    struct Function(*const ());
+    unsafe impl Sync for Function {}
+
+    static PANIC_FUNCTIONS: &[Function] = &[
+        Function(core::panicking::panic as *const ()),
+        Function(core::panicking::panic_bounds_check as *const ()),
+        Function(core::panicking::panic_fmt as *const ()),
+        Function(panicking::begin_panic_str as *const ()),
+        Function(panicking::begin_panic_fmt as *const ()),
+        Function(panicking::rust_panic_with_hook as *const ()),
+    ];
+
+    let skipped_before = frames.len() - frames.iter().rev().position(|frame| {
+        let mut addr = None;
+        resolve_symname(*frame, |syminfo| {
+            addr = syminfo.map(|a| a.1);
+            Ok(())
+        }, context).ok();
+        addr.map(|a| PANIC_FUNCTIONS.contains(&Function(a as *const ()))).unwrap_or(false)
+    }).unwrap_or(frames.len());
 
     let skipped_after = frames.len() - frames.iter().position(|frame| {
         let mut is_marker = false;
-        let _ = resolve_symname(*frame, |symname| {
-            if let Some(mangled_symbol_name) = symname {
+        let _ = resolve_symname(*frame, |syminfo| {
+            if let Some((mangled_symbol_name, _)) = syminfo {
                 // Use grep to find the concerned functions
                 if mangled_symbol_name.contains("__rust_begin_short_backtrace") {
                     is_marker = true;
@@ -125,13 +147,12 @@ fn filter_frames(frames: &[Frame],
     (skipped_before, skipped_after)
 }
 
-
 /// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`.
 #[inline(never)]
-pub fn __rust_begin_short_backtrace<F, T>(f: F) -> T
+pub fn __rust_begin_short_backtrace<F, T>(f: F) -> (T, usize)
     where F: FnOnce() -> T, F: Send + 'static, T: Send + 'static
 {
-    f()
+    (f(), 0) // The number is a dummy return value 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], libc::c_int) -> 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(), usize);
+        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).to_str().ok(), 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

@@ -399,7 +399,7 @@ 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)
+                    ::sys_common::backtrace::__rust_begin_short_backtrace(f).0
                 }));
                 #[cfg(not(feature = "backtrace"))]
                 let try_result = panic::catch_unwind(panic::AssertUnwindSafe(f));

src/libtest/lib.rs

@@ -1355,14 +1355,14 @@ pub fn convert_benchmarks_to_tests(tests: Vec<TestDescAndFn>) -> Vec<TestDescAnd
             DynBenchFn(bench) => {
                 DynTestFn(Box::new(move |()| {
                     bench::run_once(|b| {
-                        __rust_begin_short_backtrace(|| bench.run(b))
+                        __rust_begin_short_backtrace(|| bench.run(b));
                     })
                 }))
             }
             StaticBenchFn(benchfn) => {
                 DynTestFn(Box::new(move |()| {
                     bench::run_once(|b| {
-                        __rust_begin_short_backtrace(|| benchfn(b))
+                        __rust_begin_short_backtrace(|| benchfn(b));
                     })
                 }))
             }
@@ -1471,20 +1471,21 @@ pub fn run_test(opts: &TestOpts,
         }
         DynTestFn(f) => {
             let cb = move |()| {
-                __rust_begin_short_backtrace(|| f.call_box(()))
+                __rust_begin_short_backtrace(|| f.call_box(()));
             };
             run_test_inner(desc, monitor_ch, opts.nocapture, Box::new(cb))
         }
         StaticTestFn(f) =>
             run_test_inner(desc, monitor_ch, opts.nocapture,
-                           Box::new(move |()| __rust_begin_short_backtrace(f))),
+                           Box::new(move |()| {__rust_begin_short_backtrace(f); })),
     }
 }
 
 /// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`.
 #[inline(never)]
-fn __rust_begin_short_backtrace<F: FnOnce()>(f: F) {
-    f()
+fn __rust_begin_short_backtrace<F: FnOnce()>(f: F) -> usize {
+    f();
+    0 // A dummy return value to prevent tail call optimization
 }
 
 fn calc_result(desc: &TestDesc, task_result: Result<(), Box<Any + Send>>) -> TestResult {