From da887074fc70a9f8d2afec8dbe6e2eeea6fc1406 Mon Sep 17 00:00:00 2001 From: est31 Date: Tue, 27 Jun 2017 04:26:52 +0200 Subject: [PATCH 1/5] Output line column info when panicking --- src/libcore/lib.rs | 11 +++-- src/libcore/macros.rs | 10 ++-- src/libcore/panicking.rs | 30 ++++++++---- src/libcore/panicking_stage0.rs | 86 +++++++++++++++++++++++++++++++++ src/librustc_trans/mir/block.rs | 32 ++++++------ src/libstd/macros.rs | 10 ++-- src/libstd/panicking.rs | 69 +++++++++++++++++++++----- src/libstd/rt.rs | 2 +- src/libsyntax/ext/build.rs | 11 +++-- 9 files changed, 207 insertions(+), 54 deletions(-) create mode 100644 src/libcore/panicking_stage0.rs diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index b6ab1ecaf4e65..5acc6c3848a07 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -39,9 +39,9 @@ //! * `rust_begin_panic` - This function takes three arguments, a //! `fmt::Arguments`, a `&'static str`, and a `u32`. These three arguments //! dictate the panic message, the file at which panic was invoked, and the -//! line. It is up to consumers of this core library to define this panic -//! function; it is only required to never return. This requires a `lang` -//! attribute named `panic_fmt`. +//! line and column inside the file. It is up to consumers of this core +//! library to define this panic function; it is only required to never +//! return. This requires a `lang` attribute named `panic_fmt`. //! //! * `rust_eh_personality` - is used by the failure mechanisms of the //! compiler. This is often mapped to GCC's personality function, but crates @@ -160,6 +160,11 @@ pub mod array; pub mod sync; pub mod cell; pub mod char; +// FIXME: remove when SNAP +#[cfg(stage0)] +#[path = "panicking_stage0.rs"] +pub mod panicking; +#[cfg(not(stage0))] pub mod panicking; pub mod iter; pub mod option; diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs index 5bb6a772aeb62..c9761bbe61153 100644 --- a/src/libcore/macros.rs +++ b/src/libcore/macros.rs @@ -17,16 +17,18 @@ macro_rules! panic { panic!("explicit panic") ); ($msg:expr) => ({ - static _MSG_FILE_LINE: (&'static str, &'static str, u32) = ($msg, file!(), line!()); - $crate::panicking::panic(&_MSG_FILE_LINE) + static _MSG_FILE_LINE_COL: (&'static str, &'static str, u32, u32) = + ($msg, file!(), line!(), column!()); + $crate::panicking::panic_new(&_MSG_FILE_LINE_COL) }); ($fmt:expr, $($arg:tt)*) => ({ // The leading _'s are to avoid dead code warnings if this is // used inside a dead function. Just `#[allow(dead_code)]` is // insufficient, since the user may have // `#[forbid(dead_code)]` and which cannot be overridden. - static _FILE_LINE: (&'static str, u32) = (file!(), line!()); - $crate::panicking::panic_fmt(format_args!($fmt, $($arg)*), &_FILE_LINE) + static _MSG_FILE_LINE_COL: (&'static str, u32, u32) = + (file!(), line!(), column!()); + $crate::panicking::panic_fmt_new(format_args!($fmt, $($arg)*), &_MSG_FILE_LINE_COL) }); } diff --git a/src/libcore/panicking.rs b/src/libcore/panicking.rs index 60b7669f3b2d9..d4df0f69b907d 100644 --- a/src/libcore/panicking.rs +++ b/src/libcore/panicking.rs @@ -17,7 +17,7 @@ //! //! ``` //! # use std::fmt; -//! fn panic_impl(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> ! +//! fn panic_impl(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! //! # { loop {} } //! ``` //! @@ -38,35 +38,45 @@ use fmt; +#[cold] #[inline(never)] +pub fn panic_new(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! { + panic(&expr_file_line_col) +} + #[cold] #[inline(never)] // this is the slow path, always #[lang = "panic"] -pub fn panic(expr_file_line: &(&'static str, &'static str, u32)) -> ! { +pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! { // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially // reduce size overhead. The format_args! macro uses str's Display trait to // write expr, which calls Formatter::pad, which must accommodate string // truncation and padding (even though none is used here). Using // 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) = *expr_file_line; - panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line)) + let (expr, file, line, col) = *expr_file_line_col; + panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col)) } #[cold] #[inline(never)] #[lang = "panic_bounds_check"] -fn panic_bounds_check(file_line: &(&'static str, u32), +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) + len, index), file_line_col) +} + +#[cold] #[inline(never)] +pub fn panic_fmt_new(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! { + panic_fmt(fmt, &file_line_col) } #[cold] #[inline(never)] -pub fn panic_fmt(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> ! { +pub fn panic_fmt(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! { #[allow(improper_ctypes)] extern { #[lang = "panic_fmt"] #[unwind] - fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: u32) -> !; + fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: u32, col :u32) -> !; } - let (file, line) = *file_line; - unsafe { panic_impl(fmt, file, line) } + let (file, line, col) = *file_line_col; + unsafe { panic_impl(fmt, file, line, col) } } diff --git a/src/libcore/panicking_stage0.rs b/src/libcore/panicking_stage0.rs new file mode 100644 index 0000000000000..3506f6a93bc0d --- /dev/null +++ b/src/libcore/panicking_stage0.rs @@ -0,0 +1,86 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +//! Panic support for libcore +//! +//! The core library cannot define panicking, but it does *declare* panicking. This +//! means that the functions inside of libcore are allowed to panic, but to be +//! useful an upstream crate must define panicking for libcore to use. The current +//! interface for panicking is: +//! +//! ``` +//! # use std::fmt; +//! fn panic_impl(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> ! +//! # { loop {} } +//! ``` +//! +//! This definition allows for panicking with any general message, but it does not +//! allow for failing with a `Box` value. The reason for this is that libcore +//! is not allowed to allocate. +//! +//! This module contains a few other panicking functions, but these are just the +//! necessary lang items for the compiler. All panics are funneled through this +//! one function. Currently, the actual symbol is declared in the standard +//! library, but the location of this may change over time. + +#![allow(dead_code, missing_docs)] +#![unstable(feature = "core_panic", + reason = "internal details of the implementation of the `panic!` \ + and related macros", + issue = "0")] + +use fmt; + +#[cold] #[inline(never)] +pub fn panic_new(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! { + let (expr, file, line, _) = *expr_file_line_col; + let expr_file_line = (expr, file, line); + panic(&expr_file_line) +} + +#[cold] #[inline(never)] // this is the slow path, always +#[lang = "panic"] +pub fn panic(expr_file_line: &(&'static str, &'static str, u32)) -> ! { + // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially + // reduce size overhead. The format_args! macro uses str's Display trait to + // write expr, which calls Formatter::pad, which must accommodate string + // truncation and padding (even though none is used here). Using + // 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) = *expr_file_line; + panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line)) +} + +#[cold] #[inline(never)] +#[lang = "panic_bounds_check"] +fn panic_bounds_check(file_line: &(&'static str, u32), + index: usize, len: usize) -> ! { + panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}", + len, index), file_line) +} + +#[cold] #[inline(never)] +pub fn panic_fmt_new(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! { + let (file, line, _) = *file_line_col; + let file_line = (file, line); + panic_fmt(fmt, &file_line) +} + +#[cold] #[inline(never)] +pub fn panic_fmt(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> ! { + #[allow(improper_ctypes)] + extern { + #[lang = "panic_fmt"] + #[unwind] + fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: u32, col: u32) -> !; + } + let (file, line) = *file_line; + unsafe { panic_impl(fmt, file, line, 0) } +} diff --git a/src/librustc_trans/mir/block.rs b/src/librustc_trans/mir/block.rs index 16972a1b1ae24..48b166c61deb1 100644 --- a/src/librustc_trans/mir/block.rs +++ b/src/librustc_trans/mir/block.rs @@ -28,6 +28,7 @@ use type_of; use type_::Type; use syntax::symbol::Symbol; +use syntax_pos::Pos; use std::cmp; @@ -333,6 +334,7 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { let filename = Symbol::intern(&loc.file.name).as_str(); let filename = C_str_slice(bcx.ccx, filename); let line = C_u32(bcx.ccx, loc.line as u32); + let col = C_u32(bcx.ccx, loc.col.to_usize() as u32 + 1); // Put together the arguments to the panic entry point. let (lang_item, args, const_err) = match *msg { @@ -347,29 +349,29 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> { index: index as u64 })); - let file_line = C_struct(bcx.ccx, &[filename, line], false); - let align = llalign_of_min(bcx.ccx, common::val_ty(file_line)); - let file_line = consts::addr_of(bcx.ccx, - file_line, - align, - "panic_bounds_check_loc"); + let file_line_col = C_struct(bcx.ccx, &[filename, line, col], false); + let align = llalign_of_min(bcx.ccx, common::val_ty(file_line_col)); + let file_line_col = consts::addr_of(bcx.ccx, + file_line_col, + align, + "panic_bounds_check_loc"); (lang_items::PanicBoundsCheckFnLangItem, - vec![file_line, index, len], + vec![file_line_col, index, len], const_err) } mir::AssertMessage::Math(ref err) => { let msg_str = Symbol::intern(err.description()).as_str(); let msg_str = C_str_slice(bcx.ccx, msg_str); - let msg_file_line = C_struct(bcx.ccx, - &[msg_str, filename, line], + let msg_file_line_col = C_struct(bcx.ccx, + &[msg_str, filename, line, col], false); - let align = llalign_of_min(bcx.ccx, common::val_ty(msg_file_line)); - let msg_file_line = consts::addr_of(bcx.ccx, - msg_file_line, - align, - "panic_loc"); + let align = llalign_of_min(bcx.ccx, common::val_ty(msg_file_line_col)); + let msg_file_line_col = consts::addr_of(bcx.ccx, + msg_file_line_col, + align, + "panic_loc"); (lang_items::PanicFnLangItem, - vec![msg_file_line], + vec![msg_file_line_col], Some(ErrKind::Math(err.clone()))) } }; diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 9a4c5ec8f6b2e..6eb9faacf7fbe 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -41,10 +41,10 @@ macro_rules! panic { panic!("explicit panic") }); ($msg:expr) => ({ - $crate::rt::begin_panic($msg, { + $crate::rt::begin_panic_new($msg, { // static requires less code at runtime, more constant data - static _FILE_LINE: (&'static str, u32) = (file!(), line!()); - &_FILE_LINE + static _FILE_LINE_COL: (&'static str, u32, u32) = (file!(), line!(), column!()); + &_FILE_LINE_COL }) }); ($fmt:expr, $($arg:tt)+) => ({ @@ -53,8 +53,8 @@ macro_rules! panic { // used inside a dead function. Just `#[allow(dead_code)]` is // insufficient, since the user may have // `#[forbid(dead_code)]` and which cannot be overridden. - static _FILE_LINE: (&'static str, u32) = (file!(), line!()); - &_FILE_LINE + static _FILE_LINE_COL: (&'static str, u32, u32) = (file!(), line!(), column!()); + &_FILE_LINE_COL }) }); } diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs index 6f46a73698f35..1a8d3b0900920 100644 --- a/src/libstd/panicking.rs +++ b/src/libstd/panicking.rs @@ -262,6 +262,7 @@ impl<'a> PanicInfo<'a> { pub struct Location<'a> { file: &'a str, line: u32, + col: u32, } impl<'a> Location<'a> { @@ -308,6 +309,28 @@ impl<'a> Location<'a> { pub fn line(&self) -> u32 { self.line } + + /// Returns the column from which the panic originated. + /// + /// # Examples + /// + /// ```should_panic + /// use std::panic; + /// + /// panic::set_hook(Box::new(|panic_info| { + /// if let Some(location) = panic_info.location() { + /// println!("panic occured at column {}", location.column()); + /// } else { + /// println!("panic occured but can't get location information..."); + /// } + /// })); + /// + /// panic!("Normal panic"); + /// ``` + #[unstable(feature = "panic_col", issue = "42939")] + pub fn column(&self) -> u32 { + self.col + } } fn default_hook(info: &PanicInfo) { @@ -329,6 +352,7 @@ fn default_hook(info: &PanicInfo) { let file = info.location.file; let line = info.location.line; + let col = info.location.col; let msg = match info.payload.downcast_ref::<&'static str>() { Some(s) => *s, @@ -342,8 +366,8 @@ fn default_hook(info: &PanicInfo) { let name = thread.as_ref().and_then(|t| t.name()).unwrap_or(""); let write = |err: &mut ::io::Write| { - let _ = writeln!(err, "thread '{}' panicked at '{}', {}:{}", - name, msg, file, line); + let _ = writeln!(err, "thread '{}' panicked at '{}', {}:{}:{}", + name, msg, file, line, col); #[cfg(feature = "backtrace")] { @@ -467,8 +491,9 @@ pub fn panicking() -> bool { #[unwind] pub extern fn rust_begin_panic(msg: fmt::Arguments, file: &'static str, - line: u32) -> ! { - begin_panic_fmt(&msg, &(file, line)) + line: u32, + col: u32) -> ! { + begin_panic_fmt(&msg, &(file, line, col)) } /// The entry point for panicking with a formatted message. @@ -482,7 +507,7 @@ pub extern fn rust_begin_panic(msg: fmt::Arguments, issue = "0")] #[inline(never)] #[cold] pub fn begin_panic_fmt(msg: &fmt::Arguments, - file_line: &(&'static str, u32)) -> ! { + file_line_col: &(&'static str, u32, u32)) -> ! { use fmt::Write; // We do two allocations here, unfortunately. But (a) they're @@ -492,7 +517,25 @@ pub fn begin_panic_fmt(msg: &fmt::Arguments, let mut s = String::new(); let _ = s.write_fmt(*msg); - begin_panic(s, file_line) + begin_panic_new(s, file_line_col) +} + +// FIXME: remove begin_panic and rename begin_panic_new to begin_panic when SNAP + +/// This is the entry point of panicking for panic!() and assert!(). +#[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_new(msg: M, file_line_col: &(&'static str, u32, u32)) -> ! { + // Note that this should be the only allocation performed in this code path. + // Currently this means that panic!() on OOM will invoke this code path, + // but then again we're not really ready for panic on OOM anyway. If + // we do start doing this, then we should propagate this allocation to + // 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) } /// This is the entry point of panicking for panic!() and assert!(). @@ -508,7 +551,10 @@ pub fn begin_panic(msg: M, file_line: &(&'static str, u32)) -> ! // be performed in the parent of this thread instead of the thread that's // panicking. - rust_panic_with_hook(Box::new(msg), file_line) + let (file, line) = *file_line; + let file_line_col = (file, line, 0); + + rust_panic_with_hook(Box::new(msg), &file_line_col) } /// Executes the primary logic for a panic, including checking for recursive @@ -520,8 +566,8 @@ pub fn begin_panic(msg: M, file_line: &(&'static str, u32)) -> ! #[inline(never)] #[cold] fn rust_panic_with_hook(msg: Box, - file_line: &(&'static str, u32)) -> ! { - let (file, line) = *file_line; + file_line_col: &(&'static str, u32, u32)) -> ! { + let (file, line, col) = *file_line_col; let panics = update_panic_count(1); @@ -540,8 +586,9 @@ fn rust_panic_with_hook(msg: Box, let info = PanicInfo { payload: &*msg, location: Location { - file: file, - line: line, + file, + line, + col, }, }; HOOK_LOCK.read(); diff --git a/src/libstd/rt.rs b/src/libstd/rt.rs index 06fd838ea06d9..2ee63527c147c 100644 --- a/src/libstd/rt.rs +++ b/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_new, begin_panic, begin_panic_fmt, update_panic_count}; #[cfg(not(test))] #[lang = "start"] diff --git a/src/libsyntax/ext/build.rs b/src/libsyntax/ext/build.rs index a4580ea3939fb..412a34932087d 100644 --- a/src/libsyntax/ext/build.rs +++ b/src/libsyntax/ext/build.rs @@ -11,7 +11,7 @@ use abi::Abi; use ast::{self, Ident, Generics, Expr, BlockCheckMode, UnOp, PatKind}; use attr; -use syntax_pos::{Span, DUMMY_SP}; +use syntax_pos::{Pos, Span, DUMMY_SP}; use codemap::{dummy_spanned, respan, Spanned}; use ext::base::ExtCtxt; use ptr::P; @@ -768,14 +768,15 @@ impl<'a> AstBuilder for ExtCtxt<'a> { let loc = self.codemap().lookup_char_pos(span.lo); let expr_file = self.expr_str(span, Symbol::intern(&loc.file.name)); let expr_line = self.expr_u32(span, loc.line as u32); - let expr_file_line_tuple = self.expr_tuple(span, vec![expr_file, expr_line]); - let expr_file_line_ptr = self.expr_addr_of(span, expr_file_line_tuple); + let expr_col = self.expr_u32(span, loc.col.to_usize() as u32 + 1); + let expr_loc_tuple = self.expr_tuple(span, vec![expr_file, expr_line, expr_col]); + let expr_loc_ptr = self.expr_addr_of(span, expr_loc_tuple); self.expr_call_global( span, - self.std_path(&["rt", "begin_panic"]), + self.std_path(&["rt", "begin_panic_new"]), vec![ self.expr_str(span, msg), - expr_file_line_ptr]) + expr_loc_ptr]) } fn expr_unreachable(&self, span: Span) -> P { From eb5fb21bd5871a0dd3bb7bc135bc1a083ad32292 Mon Sep 17 00:00:00 2001 From: est31 Date: Wed, 28 Jun 2017 01:15:29 +0200 Subject: [PATCH 2/5] Fix the test failure, add comment, and refactor a little bit --- src/libcore/lib.rs | 5 -- src/libcore/macros.rs | 4 +- src/libcore/panicking.rs | 29 +++++++---- src/libcore/panicking_stage0.rs | 86 --------------------------------- src/libstd/panicking.rs | 19 +++++++- 5 files changed, 39 insertions(+), 104 deletions(-) delete mode 100644 src/libcore/panicking_stage0.rs diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 5acc6c3848a07..46467cd3c3e05 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -160,11 +160,6 @@ pub mod array; pub mod sync; pub mod cell; pub mod char; -// FIXME: remove when SNAP -#[cfg(stage0)] -#[path = "panicking_stage0.rs"] -pub mod panicking; -#[cfg(not(stage0))] pub mod panicking; pub mod iter; pub mod option; diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs index c9761bbe61153..70820dce5f940 100644 --- a/src/libcore/macros.rs +++ b/src/libcore/macros.rs @@ -19,7 +19,7 @@ macro_rules! panic { ($msg:expr) => ({ static _MSG_FILE_LINE_COL: (&'static str, &'static str, u32, u32) = ($msg, file!(), line!(), column!()); - $crate::panicking::panic_new(&_MSG_FILE_LINE_COL) + $crate::panicking::panic(&_MSG_FILE_LINE_COL) }); ($fmt:expr, $($arg:tt)*) => ({ // The leading _'s are to avoid dead code warnings if this is @@ -28,7 +28,7 @@ macro_rules! panic { // `#[forbid(dead_code)]` and which cannot be overridden. static _MSG_FILE_LINE_COL: (&'static str, u32, u32) = (file!(), line!(), column!()); - $crate::panicking::panic_fmt_new(format_args!($fmt, $($arg)*), &_MSG_FILE_LINE_COL) + $crate::panicking::panic_fmt(format_args!($fmt, $($arg)*), &_MSG_FILE_LINE_COL) }); } diff --git a/src/libcore/panicking.rs b/src/libcore/panicking.rs index d4df0f69b907d..eae33cf0422e5 100644 --- a/src/libcore/panicking.rs +++ b/src/libcore/panicking.rs @@ -38,13 +38,8 @@ use fmt; -#[cold] #[inline(never)] -pub fn panic_new(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! { - panic(&expr_file_line_col) -} - #[cold] #[inline(never)] // this is the slow path, always -#[lang = "panic"] +#[cfg_attr(not(stage0), lang = "panic")] pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! { // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially // reduce size overhead. The format_args! macro uses str's Display trait to @@ -56,17 +51,33 @@ pub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! { panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col)) } +// FIXME: remove when SNAP #[cold] #[inline(never)] -#[lang = "panic_bounds_check"] +#[cfg(stage0)] +#[lang = "panic"] +pub fn panic_old(expr_file_line: &(&'static str, &'static str, u32)) -> ! { + let (expr, file, line) = *expr_file_line; + let expr_file_line_col = (expr, file, line, 0); + panic(&expr_file_line_col) +} + +#[cold] #[inline(never)] +#[cfg_attr(not(stage0), 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) } +// FIXME: remove when SNAP #[cold] #[inline(never)] -pub fn panic_fmt_new(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! { - panic_fmt(fmt, &file_line_col) +#[cfg(stage0)] +#[lang = "panic_bounds_check"] +fn panic_bounds_check_old(file_line: &(&'static str, u32), + index: usize, len: usize) -> ! { + let (file, line) = *file_line; + panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}", + len, index), &(file, line, 0)) } #[cold] #[inline(never)] diff --git a/src/libcore/panicking_stage0.rs b/src/libcore/panicking_stage0.rs deleted file mode 100644 index 3506f6a93bc0d..0000000000000 --- a/src/libcore/panicking_stage0.rs +++ /dev/null @@ -1,86 +0,0 @@ -// Copyright 2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Panic support for libcore -//! -//! The core library cannot define panicking, but it does *declare* panicking. This -//! means that the functions inside of libcore are allowed to panic, but to be -//! useful an upstream crate must define panicking for libcore to use. The current -//! interface for panicking is: -//! -//! ``` -//! # use std::fmt; -//! fn panic_impl(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> ! -//! # { loop {} } -//! ``` -//! -//! This definition allows for panicking with any general message, but it does not -//! allow for failing with a `Box` value. The reason for this is that libcore -//! is not allowed to allocate. -//! -//! This module contains a few other panicking functions, but these are just the -//! necessary lang items for the compiler. All panics are funneled through this -//! one function. Currently, the actual symbol is declared in the standard -//! library, but the location of this may change over time. - -#![allow(dead_code, missing_docs)] -#![unstable(feature = "core_panic", - reason = "internal details of the implementation of the `panic!` \ - and related macros", - issue = "0")] - -use fmt; - -#[cold] #[inline(never)] -pub fn panic_new(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! { - let (expr, file, line, _) = *expr_file_line_col; - let expr_file_line = (expr, file, line); - panic(&expr_file_line) -} - -#[cold] #[inline(never)] // this is the slow path, always -#[lang = "panic"] -pub fn panic(expr_file_line: &(&'static str, &'static str, u32)) -> ! { - // Use Arguments::new_v1 instead of format_args!("{}", expr) to potentially - // reduce size overhead. The format_args! macro uses str's Display trait to - // write expr, which calls Formatter::pad, which must accommodate string - // truncation and padding (even though none is used here). Using - // 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) = *expr_file_line; - panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line)) -} - -#[cold] #[inline(never)] -#[lang = "panic_bounds_check"] -fn panic_bounds_check(file_line: &(&'static str, u32), - index: usize, len: usize) -> ! { - panic_fmt(format_args!("index out of bounds: the len is {} but the index is {}", - len, index), file_line) -} - -#[cold] #[inline(never)] -pub fn panic_fmt_new(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! { - let (file, line, _) = *file_line_col; - let file_line = (file, line); - panic_fmt(fmt, &file_line) -} - -#[cold] #[inline(never)] -pub fn panic_fmt(fmt: fmt::Arguments, file_line: &(&'static str, u32)) -> ! { - #[allow(improper_ctypes)] - extern { - #[lang = "panic_fmt"] - #[unwind] - fn panic_impl(fmt: fmt::Arguments, file: &'static str, line: u32, col: u32) -> !; - } - let (file, line) = *file_line; - unsafe { panic_impl(fmt, file, line, 0) } -} diff --git a/src/libstd/panicking.rs b/src/libstd/panicking.rs index 1a8d3b0900920..494376b831ed6 100644 --- a/src/libstd/panicking.rs +++ b/src/libstd/panicking.rs @@ -315,6 +315,7 @@ impl<'a> Location<'a> { /// # Examples /// /// ```should_panic + /// #![feature(panic_col)] /// use std::panic; /// /// panic::set_hook(Box::new(|panic_info| { @@ -327,7 +328,7 @@ impl<'a> Location<'a> { /// /// panic!("Normal panic"); /// ``` - #[unstable(feature = "panic_col", issue = "42939")] + #[unstable(feature = "panic_col", reason = "recently added", issue = "42939")] pub fn column(&self) -> u32 { self.col } @@ -520,7 +521,21 @@ pub fn begin_panic_fmt(msg: &fmt::Arguments, begin_panic_new(s, file_line_col) } -// FIXME: remove begin_panic and rename begin_panic_new to begin_panic when SNAP +// FIXME: In PR #42938, we have added the column as info passed to the panic +// handling code. For this, we want to break the ABI of begin_panic. +// This is not possible to do directly, as the stage0 compiler is hardcoded +// to emit a call to begin_panic in src/libsyntax/ext/build.rs, only +// with the file and line number being passed, but not the colum number. +// By changing the compiler source, we can only affect behaviour of higher +// stages. We need to perform the switch over two stage0 replacements, using +// a temporary function begin_panic_new while performing the switch: +// 0. Right now, we tell stage1 onward to emit a call to begin_panic_new. +// 1. In the first SNAP, stage0 calls begin_panic_new with the new ABI, +// begin_panic stops being used. Now we can change begin_panic to +// the new ABI, and start emitting calls to begin_panic in higher +// stages again, this time with the new ABI. +// 2. After the second SNAP, stage0 calls begin_panic with the new ABI, +// and we can remove the temporary begin_panic_new function. /// This is the entry point of panicking for panic!() and assert!(). #[unstable(feature = "libstd_sys_internals", From 1561954ea4c403ce7ea54cb83c944857c255b909 Mon Sep 17 00:00:00 2001 From: est31 Date: Wed, 28 Jun 2017 02:41:24 +0200 Subject: [PATCH 3/5] Documentation --- src/doc/unstable-book/src/language-features/lang-items.md | 6 ++++-- src/libcore/lib.rs | 4 ++-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/src/doc/unstable-book/src/language-features/lang-items.md b/src/doc/unstable-book/src/language-features/lang-items.md index 375b8bd6b8224..a2368ee5f4ac5 100644 --- a/src/doc/unstable-book/src/language-features/lang-items.md +++ b/src/doc/unstable-book/src/language-features/lang-items.md @@ -143,7 +143,8 @@ pub extern fn rust_eh_unwind_resume() { #[no_mangle] pub extern fn rust_begin_panic(_msg: core::fmt::Arguments, _file: &'static str, - _line: u32) -> ! { + _line: u32, + _column: u32) -> ! { unsafe { intrinsics::abort() } } ``` @@ -187,7 +188,8 @@ pub extern fn rust_eh_unwind_resume() { #[no_mangle] pub extern fn rust_begin_panic(_msg: core::fmt::Arguments, _file: &'static str, - _line: u32) -> ! { + _line: u32, + _column: u32) -> ! { unsafe { intrinsics::abort() } } ``` diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 46467cd3c3e05..97aaaffe8bc88 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -36,8 +36,8 @@ //! These functions are often provided by the system libc, but can also be //! provided by the [rlibc crate](https://crates.io/crates/rlibc). //! -//! * `rust_begin_panic` - This function takes three arguments, a -//! `fmt::Arguments`, a `&'static str`, and a `u32`. These three arguments +//! * `rust_begin_panic` - This function takes four arguments, a +//! `fmt::Arguments`, a `&'static str`, and two `u32`'s. These four arguments //! dictate the panic message, the file at which panic was invoked, and the //! line and column inside the file. It is up to consumers of this core //! library to define this panic function; it is only required to never From 57f0514febd7593f6034c293f8c0d56765bc8d51 Mon Sep 17 00:00:00 2001 From: est31 Date: Sun, 2 Jul 2017 09:06:08 +0200 Subject: [PATCH 4/5] Style fix --- src/libcore/panicking.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/libcore/panicking.rs b/src/libcore/panicking.rs index eae33cf0422e5..f5a7e78d0faa0 100644 --- a/src/libcore/panicking.rs +++ b/src/libcore/panicking.rs @@ -86,7 +86,7 @@ pub fn panic_fmt(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) 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) -> !; } let (file, line, col) = *file_line_col; unsafe { panic_impl(fmt, file, line, col) } From 3b91f9406cd4b00ef09d19aca8203ce3539a202d Mon Sep 17 00:00:00 2001 From: est31 Date: Sun, 2 Jul 2017 13:51:28 +0200 Subject: [PATCH 5/5] Update cargo ... to get https://github.com/rust-lang/cargo/pull/4244 and https://github.com/rust-lang/cargo/pull/4246 --- src/Cargo.lock | 2 +- src/tools/cargo | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Cargo.lock b/src/Cargo.lock index c66396973f8a1..2d42903ad0a7d 100644 --- a/src/Cargo.lock +++ b/src/Cargo.lock @@ -157,7 +157,7 @@ dependencies = [ [[package]] name = "cargo" version = "0.21.0" -source = "git+https://github.com/rust-lang/cargo#854bc167bbf74053f821f65cb86d506033f3d3a7" +source = "git+https://github.com/rust-lang/cargo#eb6cf012a6cc23c9c89c4009564de9fccc38b9cb" replace = "cargo 0.21.0" [[package]] diff --git a/src/tools/cargo b/src/tools/cargo index d2d6e675fcb70..eb6cf012a6cc2 160000 --- a/src/tools/cargo +++ b/src/tools/cargo @@ -1 +1 @@ -Subproject commit d2d6e675fcb70cfb91c2cf2fad8cdd345c120316 +Subproject commit eb6cf012a6cc23c9c89c4009564de9fccc38b9cb