//! * `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
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;
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)
});
}
//!
//! ```
//! # 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 {} }
//! ```
//!
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) }
}
--- /dev/null
+// 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 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, 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<Any>` 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) }
+}
use type_::Type;
use syntax::symbol::Symbol;
+use syntax_pos::Pos;
use std::cmp;
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 {
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())))
}
};
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)+) => ({
// 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
})
});
}
pub struct Location<'a> {
file: &'a str,
line: u32,
+ col: u32,
}
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) {
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,
let name = thread.as_ref().and_then(|t| t.name()).unwrap_or("<unnamed>");
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")]
{
#[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.
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
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<M: Any + Send>(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!().
// 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
#[inline(never)]
#[cold]
fn rust_panic_with_hook(msg: Box<Any + Send>,
- 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);
let info = PanicInfo {
payload: &*msg,
location: Location {
- file: file,
- line: line,
+ file,
+ line,
+ col,
},
};
HOOK_LOCK.read();
// 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"]
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;
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<ast::Expr> {
projects / rust.git / commitdiff