---

yaml
---
r: 156537
b: refs/heads/master
c: 3e9ce5a
h: refs/heads/master
i:
  156535: 8b20224
v: v3

Author: Jakub Bukaj

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 172b59abe510dde5826fec24377f208a19418c04
+refs/heads/master: 3e9ce5afb776bf5a187cafa8cfe5ad677bfd3acc
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: d44ea720fa9dfe062ef06d0eb49a58d4e7e92344
 refs/heads/try: 6601b0501e31d08d3892a2d5a7d8a57ab120bf75

trunk/src/libcore/intrinsics.rs

@@ -260,17 +260,6 @@ 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,7 +81,6 @@ 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,11 +82,6 @@ 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,13 +486,6 @@ 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,6 +252,16 @@ 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,8 +132,7 @@ 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),
-                             rt::thread::main_guard_page());
+    let mut task = task::new((my_stack_bottom, my_stack_top));
     task.name = Some(str::Slice("<main>"));
     drop(task.run(|| {
         unsafe {

trunk/src/libnative/task.rs

@@ -29,11 +29,10 @@ 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), stack_guard: uint) -> Box<Task> {
+pub fn new(stack_bounds: (uint, 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;
 }
@@ -45,7 +44,6 @@ fn ops() -> Box<Ops> {
         io: io::IoFactory::new(),
         // these *should* get overwritten
         stack_bounds: (0, 0),
-        stack_guard: 0
     }
 }
 
@@ -84,7 +82,6 @@ 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);
@@ -118,8 +115,6 @@ 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 {
@@ -143,14 +138,6 @@ 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/resolve.rs

@@ -5077,7 +5077,6 @@ impl<'a> Resolver<'a> {
                 PatEnum(ref path, _) => {
                     // This must be an enum variant, struct or const.
                     match self.resolve_path(pat_id, path, ValueNS, false) {
-                        Some(def @ (DefFn(..), _))      |
                         Some(def @ (DefVariant(..), _)) |
                         Some(def @ (DefStruct(..), _))  |
                         Some(def @ (DefConst(..), _)) => {

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

@@ -860,7 +860,6 @@ 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,7 +81,6 @@ 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

@@ -5703,8 +5703,6 @@ 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,7 +51,6 @@ mod local_ptr;
 mod thread_local_storage;
 mod util;
 mod libunwind;
-mod stack_overflow;
 
 pub mod args;
 pub mod bookkeeping;
@@ -93,8 +92,6 @@ 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.
@@ -116,7 +113,6 @@ 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
@@ -155,7 +151,6 @@ 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,6 +55,10 @@ 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 {
@@ -100,7 +104,21 @@ extern fn stack_exhausted() {
         //  #9854 - unwinding on windows through __morestack has never worked
         //  #2361 - possible implementation of not using landing pads
 
-        ::stack_overflow::report();
+        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);
 
         intrinsics::abort();
     }