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",