---

yaml
---
r: 156540
b: refs/heads/master
c: a34b8de
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1484f9cd46013a227d1d057508ff57ebc5930a8d
+refs/heads/master: a34b8dec697014f15e725215e17ea8d956c0ab1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d44ea720fa9dfe062ef06d0eb49a58d4e7e92344
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75

trunk/src/libcore/intrinsics.rs

@@ -260,6 +260,17 @@ extern "rust-intrinsic" {
     /// NB: This is very different from the `unreachable!()` macro!
     pub fn unreachable() -> !;
 
+    /// Inform the optimizer that a condition is always true.
+    /// If the condition is false, the behavior is undefined.
+    ///
+    /// No code is generated for this intrinsic, but the optimizer will try
+    /// to preserve it (and its condition) between passes, which may interfere
+    /// with optimization of surrounding code and reduce performance. It should
+    /// not be used if the invariant can be discovered by the optimizer on its
+    /// own, or if it does not enable any significant optimizations.
+    #[cfg(not(stage0))]
+    pub fn assume(b: bool);
+
     /// Execute a breakpoint trap, for inspection by a debugger.
     pub fn breakpoint();
 

trunk/src/libgreen/simple.rs

@@ -81,6 +81,7 @@ impl Runtime for SimpleTask {
     }
     fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>> { None }
     fn stack_bounds(&self) -> (uint, uint) { fail!() }
+    fn stack_guard(&self) -> Option<uint> { fail!() }
     fn can_block(&self) -> bool { true }
     fn wrap(self: Box<SimpleTask>) -> Box<Any+'static> { fail!() }
 }

trunk/src/libgreen/stack.rs

@@ -82,6 +82,11 @@ impl Stack {
         }
     }
 
+    /// Point to the last writable byte of the stack
+    pub fn guard(&self) -> *const uint {
+        (self.start() as uint + page_size()) as *const uint
+    }
+
     /// Point to the low end of the allocated stack
     pub fn start(&self) -> *const uint {
         self.buf.as_ref().map(|m| m.data() as *const uint)

trunk/src/libgreen/task.rs

@@ -486,6 +486,13 @@ impl Runtime for GreenTask {
          c.current_stack_segment.end() as uint)
     }
 
+    fn stack_guard(&self) -> Option<uint> {
+        let c = self.coroutine.as_ref()
+            .expect("GreenTask.stack_guard called without a coroutine");
+
+        Some(c.current_stack_segment.guard() as uint)
+    }
+
     fn can_block(&self) -> bool { false }
 
     fn wrap(self: Box<GreenTask>) -> Box<Any+'static> {

trunk/src/libnative/io/c_unix.rs

@@ -252,16 +252,6 @@ mod signal {
         pub status: libc::c_int,
     }
 
-    #[cfg(any(target_os = "macos", target_os = "ios"))]
-    #[repr(C)]
-    pub struct sigaction {
-        pub sa_handler: extern fn(libc::c_int),
-        sa_tramp: *mut libc::c_void,
-        pub sa_mask: sigset_t,
-        pub sa_flags: libc::c_int,
-    }
-
-    #[cfg(any(target_os = "freebsd", target_os = "dragonfly"))]
     #[repr(C)]
     pub struct sigaction {
         pub sa_handler: extern fn(libc::c_int),

trunk/src/libnative/lib.rs

@@ -132,7 +132,8 @@ pub fn start(argc: int, argv: *const *const u8, main: proc()) -> int {
     rt::init(argc, argv);
     let mut exit_code = None;
     let mut main = Some(main);
-    let mut task = task::new((my_stack_bottom, my_stack_top));
+    let mut task = task::new((my_stack_bottom, my_stack_top),
+                             rt::thread::main_guard_page());
     task.name = Some(str::Slice("<main>"));
     drop(task.run(|| {
         unsafe {

trunk/src/libnative/task.rs

@@ -29,10 +29,11 @@ use io;
 use std::task::{TaskBuilder, Spawner};
 
 /// Creates a new Task which is ready to execute as a 1:1 task.
-pub fn new(stack_bounds: (uint, uint)) -> Box<Task> {
+pub fn new(stack_bounds: (uint, uint), stack_guard: uint) -> Box<Task> {
     let mut task = box Task::new();
     let mut ops = ops();
     ops.stack_bounds = stack_bounds;
+    ops.stack_guard = stack_guard;
     task.put_runtime(ops);
     return task;
 }
@@ -44,6 +45,7 @@ fn ops() -> Box<Ops> {
         io: io::IoFactory::new(),
         // these *should* get overwritten
         stack_bounds: (0, 0),
+        stack_guard: 0
     }
 }
 
@@ -82,6 +84,7 @@ impl Spawner for NativeSpawner {
                                                       my_stack);
             }
             let mut ops = ops;
+            ops.stack_guard = rt::thread::current_guard_page();
             ops.stack_bounds = (my_stack - stack + 1024, my_stack);
 
             let mut f = Some(f);
@@ -115,6 +118,8 @@ struct Ops {
     // native tasks necessarily know their precise bounds, hence this is
     // optional.
     stack_bounds: (uint, uint),
+
+    stack_guard: uint
 }
 
 impl rt::Runtime for Ops {
@@ -138,6 +143,14 @@ impl rt::Runtime for Ops {
 
     fn stack_bounds(&self) -> (uint, uint) { self.stack_bounds }
 
+    fn stack_guard(&self) -> Option<uint> {
+        if self.stack_guard != 0 {
+            Some(self.stack_guard)
+        } else {
+            None
+        }
+    }
+
     fn can_block(&self) -> bool { true }
 
     // This function gets a little interesting. There are a few safety and

trunk/src/librustc/middle/trans/context.rs

@@ -860,6 +860,7 @@ fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef
     ifn!("llvm.lifetime.end" fn(t_i64, i8p) -> void);
 
     ifn!("llvm.expect.i1" fn(i1, i1) -> i1);
+    ifn!("llvm.assume" fn(i1) -> void);
 
     // Some intrinsics were introduced in later versions of LLVM, but they have
     // fallbacks in libc or libm and such. Currently, all of these intrinsics

trunk/src/librustc/middle/trans/intrinsic.rs

@@ -81,6 +81,7 @@ pub fn get_simple_intrinsic(ccx: &CrateContext, item: &ast::ForeignItem) -> Opti
         "bswap16" => "llvm.bswap.i16",
         "bswap32" => "llvm.bswap.i32",
         "bswap64" => "llvm.bswap.i64",
+        "assume" => "llvm.assume",
         _ => return None
     };
     Some(ccx.get_intrinsic(&name))

trunk/src/librustc/middle/typeck/check/mod.rs

@@ -5707,6 +5707,8 @@ pub fn check_intrinsic_type(ccx: &CrateCtxt, it: &ast::ForeignItem) {
 
             "return_address" => (0, vec![], ty::mk_imm_ptr(tcx, ty::mk_u8())),
 
+            "assume" => (0, vec![ty::mk_bool()], ty::mk_nil()),
+
             ref other => {
                 span_err!(tcx.sess, it.span, E0093,
                     "unrecognized intrinsic function: `{}`", *other);

trunk/src/librustrt/lib.rs

@@ -51,6 +51,7 @@ mod local_ptr;
 mod thread_local_storage;
 mod util;
 mod libunwind;
+mod stack_overflow;
 
 pub mod args;
 pub mod bookkeeping;
@@ -92,6 +93,8 @@ pub trait Runtime {
     fn local_io<'a>(&'a mut self) -> Option<rtio::LocalIo<'a>>;
     /// The (low, high) edges of the current stack.
     fn stack_bounds(&self) -> (uint, uint); // (lo, hi)
+    /// The last writable byte of the stack next to the guard page
+    fn stack_guard(&self) -> Option<uint>;
     fn can_block(&self) -> bool;
 
     // FIXME: This is a serious code smell and this should not exist at all.
@@ -113,6 +116,7 @@ pub fn init(argc: int, argv: *const *const u8) {
         args::init(argc, argv);
         local_ptr::init();
         at_exit_imp::init();
+        thread::init();
     }
 
     // FIXME(#14344) this shouldn't be necessary
@@ -151,6 +155,7 @@ pub unsafe fn cleanup() {
     bookkeeping::wait_for_other_tasks();
     at_exit_imp::run();
     args::cleanup();
+    thread::cleanup();
     local_ptr::cleanup();
 }
 

trunk/src/librustrt/stack.rs

@@ -55,10 +55,6 @@ pub const RED_ZONE: uint = 20 * 1024;
 #[cfg(not(test))] // in testing, use the original libstd's version
 #[lang = "stack_exhausted"]
 extern fn stack_exhausted() {
-    use core::prelude::*;
-    use alloc::boxed::Box;
-    use local::Local;
-    use task::Task;
     use core::intrinsics;
 
     unsafe {
@@ -104,21 +100,7 @@ extern fn stack_exhausted() {
         //  #9854 - unwinding on windows through __morestack has never worked
         //  #2361 - possible implementation of not using landing pads
 
-        let task: Option<Box<Task>> = Local::try_take();
-        let name = match task {
-            Some(ref task) => {
-                task.name.as_ref().map(|n| n.as_slice())
-            }
-            None => None
-        };
-        let name = name.unwrap_or("<unknown>");
-
-        // See the message below for why this is not emitted to the
-        // task's logger. This has the additional conundrum of the
-        // logger may not be initialized just yet, meaning that an FFI
-        // call would happen to initialized it (calling out to libuv),
-        // and the FFI call needs 2MB of stack when we just ran out.
-        rterrln!("task '{}' has overflowed its stack", name);
+        ::stack_overflow::report();
 
         intrinsics::abort();
     }