Make most of the failure functions take &(&'static str, uint)

Passing one pointer takes less code than one pointer and an integer.

diff --git a/src/libcore/failure.rs b/src/libcore/failure.rs
index 4bc39db8ecf0932e2baef0c8e67406ed325f5110..022258911f1e09b419c86d2437df7d7aeb66ea2e 100644 (file)
--- a/src/libcore/failure.rs
+++ b/src/libcore/failure.rs
@@ -33,33 +33,72 @@
 use fmt;
 use intrinsics;
 
+#[cfg(stage0)]
 #[cold] #[inline(never)] // this is the slow path, always
 #[lang="fail_"]
 fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
     format_args!(|args| -> () {
-        begin_unwind(args, file, line);
+        begin_unwind(args, &(file, line));
     }, "{}", expr);
 
     unsafe { intrinsics::abort() }
 }
 
+#[cfg(stage0)]
 #[cold]
 #[lang="fail_bounds_check"]
 fn fail_bounds_check(file: &'static str, line: uint,
                      index: uint, len: uint) -> ! {
     format_args!(|args| -> () {
-        begin_unwind(args, file, line);
+        begin_unwind(args, &(file, line));
     }, "index out of bounds: the len is {} but the index is {}", len, index);
     unsafe { intrinsics::abort() }
 }
 
+#[cfg(stage0)]
 #[cold]
-pub fn begin_unwind(fmt: &fmt::Arguments, file: &'static str, line: uint) -> ! {
+pub fn begin_unwind(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
     #[allow(ctypes)]
     extern {
         #[lang = "begin_unwind"]
         fn begin_unwind(fmt: &fmt::Arguments, file: &'static str,
                         line: uint) -> !;
     }
+    let (file, line) = *file_line;
+    unsafe { begin_unwind(fmt, file, line) }
+}
+
+#[cfg(not(stage0))]
+#[cold] #[inline(never)] // this is the slow path, always
+#[lang="fail_"]
+fn fail_(expr: &'static str, file: &'static str, line: uint) -> ! {
+    format_args!(|args| -> () {
+        begin_unwind(args, &(file, line));
+    }, "{}", expr);
+
+    unsafe { intrinsics::abort() }
+}
+
+#[cfg(not(stage0))]
+#[cold]
+#[lang="fail_bounds_check"]
+fn fail_bounds_check(file: &'static str, line: uint,
+                     index: uint, len: uint) -> ! {
+    format_args!(|args| -> () {
+        begin_unwind(args, &(file, line));
+    }, "index out of bounds: the len is {} but the index is {}", len, index);
+    unsafe { intrinsics::abort() }
+}
+
+#[cfg(not(stage0))]
+#[cold]
+pub fn begin_unwind(fmt: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
+    #[allow(ctypes)]
+    extern {
+        #[lang = "begin_unwind"]
+        fn begin_unwind(fmt: &fmt::Arguments, file_line: &'static str,
+                        line: uint) -> !;
+    }
+    let (file, line) = *file_line;
     unsafe { begin_unwind(fmt, file, line) }
 }

diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
index 93c838198c559b60792b945f2f49cfa68af86089..e2709c4edde475b1a64747012e0f49eef76ed3ce 100644 (file)
--- a/src/libcore/macros.rs
+++ b/src/libcore/macros.rs
@@ -33,7 +33,7 @@ macro_rules! fail(
         // up with the number of calls to fail!()
         #[inline(always)]
         fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
-            ::core::failure::begin_unwind(fmt, file!(), line!())
+            ::core::failure::begin_unwind(fmt, &(file!(), line!()))
         }
         format_args!(run_fmt, $fmt, $($arg)*)
     });

diff --git a/src/librustrt/unwind.rs b/src/librustrt/unwind.rs
index cb1b6f46afe3628e3f989c61ce5fe12420afd9a0..db2cae2371821355b4adcba7b363a41852ce9eb4 100644 (file)
--- a/src/librustrt/unwind.rs
+++ b/src/librustrt/unwind.rs
@@ -384,7 +384,7 @@ pub extern "C" fn rust_eh_personality_catch(
 #[lang = "begin_unwind"]
 pub extern fn rust_begin_unwind(msg: &fmt::Arguments,
                                 file: &'static str, line: uint) -> ! {
-    begin_unwind_fmt(msg, file, line)
+    begin_unwind_fmt(msg, &(file, line))
 }
 
 /// The entry point for unwinding with a formatted message.
@@ -394,8 +394,7 @@ pub extern "C" fn rust_eh_personality_catch(
 /// on (e.g.) the inlining of other functions as possible), by moving
 /// the actual formatting into this shared place.
 #[inline(never)] #[cold]
-pub fn begin_unwind_fmt(msg: &fmt::Arguments, file: &'static str,
-                        line: uint) -> ! {
+pub fn begin_unwind_fmt(msg: &fmt::Arguments, file_line: &(&'static str, uint)) -> ! {
     use core::fmt::FormatWriter;
 
     // We do two allocations here, unfortunately. But (a) they're
@@ -415,9 +414,10 @@ fn write(&mut self, buf: &[u8]) -> fmt::Result {
     let mut v = Vec::new();
     let _ = write!(&mut VecWriter { v: &mut v }, "{}", msg);
 
-    begin_unwind_inner(box String::from_utf8(v).unwrap(), file, line)
+    begin_unwind_inner(box String::from_utf8(v).unwrap(), file_line)
 }
 
+// FIXME: Need to change expr_fail in AstBuilder to change this to &(str, uint)
 /// This is the entry point of unwinding for fail!() and assert!().
 #[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible
 pub fn begin_unwind<M: Any + Send>(msg: M, file: &'static str, line: uint) -> ! {
@@ -429,13 +429,13 @@ pub fn begin_unwind<M: Any + Send>(msg: M, file: &'static str, line: uint) -> !
     // failing.
 
     // see below for why we do the `Any` coercion here.
-    begin_unwind_inner(box msg, file, line)
+    begin_unwind_inner(box msg, &(file, line))
 }
 
 /// Unwinding for `fail!()`. Saves passing a string.
 #[inline(never)] #[cold] #[experimental]
-pub fn begin_unwind_no_time_to_explain(file: &'static str, line: uint) -> ! {
-    begin_unwind_inner(box () ("explicit failure"), file, line)
+pub fn begin_unwind_no_time_to_explain(file_line: &(&'static str, uint)) -> ! {
+    begin_unwind_inner(box () ("explicit failure"), file_line)
 }
 
 /// The core of the unwinding.
@@ -448,9 +448,7 @@ pub fn begin_unwind_no_time_to_explain(file: &'static str, line: uint) -> ! {
 /// Do this split took the LLVM IR line counts of `fn main() { fail!()
 /// }` from ~1900/3700 (-O/no opts) to 180/590.
 #[inline(never)] #[cold] // this is the slow path, please never inline this
-fn begin_unwind_inner(msg: Box<Any + Send>,
-                      file: &'static str,
-                      line: uint) -> ! {
+fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) -> ! {
     // First, invoke call the user-defined callbacks triggered on task failure.
     //
     // By the time that we see a callback has been registered (by reading
@@ -467,6 +465,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>,
             0 => {}
             n => {
                 let f: Callback = unsafe { mem::transmute(n) };
+                let (file, line) = *file_line;
                 f(msg, file, line);
             }
         }

diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 3c6c860f516bb63c8c5cd4724a02af5285fc60a0..fd0c72ce313eefdae380d90db4b45b1353d0b426 100644 (file)
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -39,7 +39,7 @@
 #[macro_export]
 macro_rules! fail(
     () => (
-        ::std::rt::begin_unwind_no_time_to_explain(file!(), line!())
+        ::std::rt::begin_unwind_no_time_to_explain(&(file!(), line!()))
     );
     ($msg:expr) => (
         ::std::rt::begin_unwind($msg, file!(), line!())
@@ -58,7 +58,7 @@ macro_rules! fail(
         // up with the number of calls to fail!()
         #[inline(always)]
         fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
-            ::std::rt::begin_unwind_fmt(fmt, file!(), line!())
+            ::std::rt::begin_unwind_fmt(fmt, &(file!(), line!()))
         }
         format_args!(run_fmt, $fmt, $($arg)*)
     });