From 744ba627f34ebf76b5a784085645780066d8d92a Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Sat, 20 Apr 2013 00:33:49 -0700
Subject: core::rt: Add a test mod and put run_in_newsched_task there

---
 src/libcore/task/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/libcore/task')

diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs
index a6c03638713..a243bfba85c 100644
--- a/src/libcore/task/mod.rs
+++ b/src/libcore/task/mod.rs
@@ -1229,7 +1229,7 @@ fn test_spawn_thread_on_demand() {
 
 #[test]
 fn test_simple_newsched_spawn() {
-    use rt::run_in_newsched_task;
+    use rt::test::run_in_newsched_task;
 
     do run_in_newsched_task {
         spawn(||())
-- 
cgit 1.4.1-3-g733a5


From d0786fdffcbae5c89762455fd3b3ffb5b9a3b6a1 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Mon, 22 Apr 2013 12:54:03 -0700
Subject: core::rt Wire up task-local storage to the new scheduler

---
 src/libcore/rt/local_services.rs    | 58 +++++++++++++++++++++++--
 src/libcore/rt/sched/mod.rs         |  7 +++
 src/libcore/task/local_data.rs      | 10 ++---
 src/libcore/task/local_data_priv.rs | 87 +++++++++++++++++++++++++++++++------
 src/libcore/task/spawn.rs           |  8 ++--
 5 files changed, 144 insertions(+), 26 deletions(-)

(limited to 'src/libcore/task')

diff --git a/src/libcore/rt/local_services.rs b/src/libcore/rt/local_services.rs
index b9d99283e14..d29e57a17af 100644
--- a/src/libcore/rt/local_services.rs
+++ b/src/libcore/rt/local_services.rs
@@ -19,6 +19,7 @@
 //! (freestanding rust with local services?).
 
 use prelude::*;
+use libc::c_void;
 use super::sched::{Task, local_sched};
 use super::local_heap::LocalHeap;
 
@@ -27,11 +28,12 @@ pub struct LocalServices {
     gc: GarbageCollector,
     storage: LocalStorage,
     logger: Logger,
-    unwinder: Unwinder
+    unwinder: Unwinder,
+    destroyed: bool
 }
 
 pub struct GarbageCollector;
-pub struct LocalStorage;
+pub struct LocalStorage(*c_void, Option<~fn(*c_void)>);
 pub struct Logger;
 pub struct Unwinder;
 
@@ -40,11 +42,34 @@ impl LocalServices {
         LocalServices {
             heap: LocalHeap::new(),
             gc: GarbageCollector,
-            storage: LocalStorage,
+            storage: LocalStorage(ptr::null(), None),
             logger: Logger,
-            unwinder: Unwinder
+            unwinder: Unwinder,
+            destroyed: false
         }
     }
+
+    /// Must be called manually before finalization to clean up
+    /// thread-local resources. Some of the routines here expect
+    /// LocalServices to be available recursively so this must be
+    /// called unsafely, without removing LocalServices from
+    /// thread-local-storage.
+    pub fn destroy(&mut self) {
+        // This is just an assertion that `destroy` was called unsafely
+        // and this instance of LocalServices is still accessible.
+        do borrow_local_services |sched| {
+            assert!(ptr::ref_eq(sched, self));
+        }
+        match self.storage {
+            LocalStorage(ptr, Some(ref dtor)) => (*dtor)(ptr),
+            _ => ()
+        }
+        self.destroyed = true;
+    }
+}
+
+impl Drop for LocalServices {
+    fn finalize(&self) { assert!(self.destroyed) }
 }
 
 /// Borrow a pointer to the installed local services.
@@ -62,6 +87,19 @@ pub fn borrow_local_services(f: &fn(&mut LocalServices)) {
     }
 }
 
+pub unsafe fn unsafe_borrow_local_services() -> &mut LocalServices {
+    use cast::transmute_mut_region;
+
+    match local_sched::unsafe_borrow().current_task {
+        Some(~ref mut task) => {
+            transmute_mut_region(&mut task.local_services)
+        }
+        None => {
+            fail!(~"no local services for schedulers yet")
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use rt::test::*;
@@ -75,4 +113,16 @@ mod test {
             assert!(*b == 5);
         }
     }
+
+    #[test]
+    fn tls() {
+        use task::local_data::*;
+        do run_in_newsched_task() {
+            unsafe {
+                fn key(_x: @~str) { }
+                local_data_set(key, @~"data");
+                assert!(*local_data_get(key).get() == ~"data");
+            }
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/libcore/rt/sched/mod.rs b/src/libcore/rt/sched/mod.rs
index 30136e443ee..b7d861b8946 100644
--- a/src/libcore/rt/sched/mod.rs
+++ b/src/libcore/rt/sched/mod.rs
@@ -357,6 +357,13 @@ pub impl Task {
 
             start();
 
+            unsafe {
+                // Destroy the local heap, TLS, etc.
+                let sched = local_sched::unsafe_borrow();
+                let task = sched.current_task.get_mut_ref();
+                task.local_services.destroy();
+            }
+
             let sched = local_sched::take();
             sched.terminate_current_task();
         };
diff --git a/src/libcore/task/local_data.rs b/src/libcore/task/local_data.rs
index 261671f6de9..6e919a74ed4 100644
--- a/src/libcore/task/local_data.rs
+++ b/src/libcore/task/local_data.rs
@@ -27,7 +27,7 @@ magic.
 */
 
 use prelude::*;
-use task::local_data_priv::{local_get, local_pop, local_modify, local_set};
+use task::local_data_priv::{local_get, local_pop, local_modify, local_set, Handle};
 use task::rt;
 
 /**
@@ -53,7 +53,7 @@ pub type LocalDataKey<'self,T> = &'self fn(v: @T);
 pub unsafe fn local_data_pop<T:Durable>(
     key: LocalDataKey<T>) -> Option<@T> {
 
-    local_pop(rt::rust_get_task(), key)
+    local_pop(Handle::new(), key)
 }
 /**
  * Retrieve a task-local data value. It will also be kept alive in the
@@ -62,7 +62,7 @@ pub unsafe fn local_data_pop<T:Durable>(
 pub unsafe fn local_data_get<T:Durable>(
     key: LocalDataKey<T>) -> Option<@T> {
 
-    local_get(rt::rust_get_task(), key)
+    local_get(Handle::new(), key)
 }
 /**
  * Store a value in task-local data. If this key already has a value,
@@ -71,7 +71,7 @@ pub unsafe fn local_data_get<T:Durable>(
 pub unsafe fn local_data_set<T:Durable>(
     key: LocalDataKey<T>, data: @T) {
 
-    local_set(rt::rust_get_task(), key, data)
+    local_set(Handle::new(), key, data)
 }
 /**
  * Modify a task-local data value. If the function returns 'None', the
@@ -81,7 +81,7 @@ pub unsafe fn local_data_modify<T:Durable>(
     key: LocalDataKey<T>,
     modify_fn: &fn(Option<@T>) -> Option<@T>) {
 
-    local_modify(rt::rust_get_task(), key, modify_fn)
+    local_modify(Handle::new(), key, modify_fn)
 }
 
 #[test]
diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs
index 43f5fa4654b..50e8286e738 100644
--- a/src/libcore/task/local_data_priv.rs
+++ b/src/libcore/task/local_data_priv.rs
@@ -18,6 +18,30 @@ use task::rt;
 use task::local_data::LocalDataKey;
 
 use super::rt::rust_task;
+use rt::local_services::LocalStorage;
+
+pub enum Handle {
+    OldHandle(*rust_task),
+    NewHandle(*mut LocalStorage)
+}
+
+impl Handle {
+    pub fn new() -> Handle {
+        use rt::{context, OldTaskContext};
+        use rt::local_services::unsafe_borrow_local_services;
+        unsafe {
+            match context() {
+                OldTaskContext => {
+                    OldHandle(rt::rust_get_task())
+                }
+                _ => {
+                    let local_services = unsafe_borrow_local_services();
+                    NewHandle(&mut local_services.storage)
+                }
+            }
+        }
+    }
+}
 
 pub trait LocalData { }
 impl<T:Durable> LocalData for @T { }
@@ -39,7 +63,7 @@ type TaskLocalElement = (*libc::c_void, *libc::c_void, @LocalData);
 // Has to be a pointer at outermost layer; the foreign call returns void *.
 type TaskLocalMap = @mut ~[Option<TaskLocalElement>];
 
-extern fn cleanup_task_local_map(map_ptr: *libc::c_void) {
+fn cleanup_task_local_map(map_ptr: *libc::c_void) {
     unsafe {
         assert!(!map_ptr.is_null());
         // Get and keep the single reference that was created at the
@@ -50,8 +74,19 @@ extern fn cleanup_task_local_map(map_ptr: *libc::c_void) {
 }
 
 // Gets the map from the runtime. Lazily initialises if not done so already.
+unsafe fn get_local_map(handle: Handle) -> TaskLocalMap {
+    match handle {
+        OldHandle(task) => get_task_local_map(task),
+        NewHandle(local_storage) => get_newsched_local_map(local_storage)
+    }
+}
+
 unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
 
+    extern fn cleanup_task_local_map_(map_ptr: *libc::c_void) {
+        cleanup_task_local_map(map_ptr);
+    }
+
     // Relies on the runtime initialising the pointer to null.
     // Note: The map's box lives in TLS invisibly referenced once. Each time
     // we retrieve it for get/set, we make another reference, which get/set
@@ -62,7 +97,7 @@ unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
         // Use reinterpret_cast -- transmute would take map away from us also.
         rt::rust_set_task_local_data(
             task, cast::reinterpret_cast(&map));
-        rt::rust_task_local_data_atexit(task, cleanup_task_local_map);
+        rt::rust_task_local_data_atexit(task, cleanup_task_local_map_);
         // Also need to reference it an extra time to keep it for now.
         let nonmut = cast::transmute::<TaskLocalMap,
                                        @~[Option<TaskLocalElement>]>(map);
@@ -77,6 +112,32 @@ unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
     }
 }
 
+unsafe fn get_newsched_local_map(local: *mut LocalStorage) -> TaskLocalMap {
+    match &mut *local {
+        &LocalStorage(map_ptr, Some(_)) => {
+            assert!(map_ptr.is_not_null());
+            let map = cast::transmute(map_ptr);
+            let nonmut = cast::transmute::<TaskLocalMap,
+            @~[Option<TaskLocalElement>]>(map);
+            cast::bump_box_refcount(nonmut);
+            return map;
+        }
+        &LocalStorage(ref mut map_ptr, ref mut at_exit) => {
+            assert!((*map_ptr).is_null());
+            let map: TaskLocalMap = @mut ~[];
+            // Use reinterpret_cast -- transmute would take map away from us also.
+            *map_ptr = cast::reinterpret_cast(&map);
+            let at_exit_fn: ~fn(*libc::c_void) = |p|cleanup_task_local_map(p);
+            *at_exit = Some(at_exit_fn);
+            // Also need to reference it an extra time to keep it for now.
+            let nonmut = cast::transmute::<TaskLocalMap,
+            @~[Option<TaskLocalElement>]>(map);
+            cast::bump_box_refcount(nonmut);
+            return map;
+        }
+    }
+}
+
 unsafe fn key_to_key_value<T:Durable>(
     key: LocalDataKey<T>) -> *libc::c_void {
 
@@ -106,10 +167,10 @@ unsafe fn local_data_lookup<T:Durable>(
 }
 
 unsafe fn local_get_helper<T:Durable>(
-    task: *rust_task, key: LocalDataKey<T>,
+    handle: Handle, key: LocalDataKey<T>,
     do_pop: bool) -> Option<@T> {
 
-    let map = get_task_local_map(task);
+    let map = get_local_map(handle);
     // Interpreturn our findings from the map
     do local_data_lookup(map, key).map |result| {
         // A reference count magically appears on 'data' out of thin air. It
@@ -128,23 +189,23 @@ unsafe fn local_get_helper<T:Durable>(
 
 
 pub unsafe fn local_pop<T:Durable>(
-    task: *rust_task,
+    handle: Handle,
     key: LocalDataKey<T>) -> Option<@T> {
 
-    local_get_helper(task, key, true)
+    local_get_helper(handle, key, true)
 }
 
 pub unsafe fn local_get<T:Durable>(
-    task: *rust_task,
+    handle: Handle,
     key: LocalDataKey<T>) -> Option<@T> {
 
-    local_get_helper(task, key, false)
+    local_get_helper(handle, key, false)
 }
 
 pub unsafe fn local_set<T:Durable>(
-    task: *rust_task, key: LocalDataKey<T>, data: @T) {
+    handle: Handle, key: LocalDataKey<T>, data: @T) {
 
-    let map = get_task_local_map(task);
+    let map = get_local_map(handle);
     // Store key+data as *voids. Data is invisibly referenced once; key isn't.
     let keyval = key_to_key_value(key);
     // We keep the data in two forms: one as an unsafe pointer, so we can get
@@ -174,12 +235,12 @@ pub unsafe fn local_set<T:Durable>(
 }
 
 pub unsafe fn local_modify<T:Durable>(
-    task: *rust_task, key: LocalDataKey<T>,
+    handle: Handle, key: LocalDataKey<T>,
     modify_fn: &fn(Option<@T>) -> Option<@T>) {
 
     // Could be more efficient by doing the lookup work, but this is easy.
-    let newdata = modify_fn(local_pop(task, key));
+    let newdata = modify_fn(local_pop(handle, key));
     if newdata.is_some() {
-        local_set(task, key, newdata.unwrap());
+        local_set(handle, key, newdata.unwrap());
     }
 }
diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs
index 118c4cc2312..1e3857dff9a 100644
--- a/src/libcore/task/spawn.rs
+++ b/src/libcore/task/spawn.rs
@@ -80,7 +80,7 @@ use prelude::*;
 use unstable;
 use ptr;
 use hashmap::HashSet;
-use task::local_data_priv::{local_get, local_set};
+use task::local_data_priv::{local_get, local_set, OldHandle};
 use task::rt::rust_task;
 use task::rt;
 use task::{Failure, ManualThreads, PlatformThread, SchedOpts, SingleThreaded};
@@ -451,7 +451,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
         /*##################################################################*
          * Step 1. Get spawner's taskgroup info.
          *##################################################################*/
-        let spawner_group = match local_get(spawner, taskgroup_key!()) {
+        let spawner_group = match local_get(OldHandle(spawner), taskgroup_key!()) {
             None => {
                 // Main task, doing first spawn ever. Lazily initialise here.
                 let mut members = new_taskset();
@@ -463,7 +463,7 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
                 // Main task/group has no ancestors, no notifier, etc.
                 let group =
                     @TCB(spawner, tasks, AncestorList(None), true, None);
-                local_set(spawner, taskgroup_key!(), group);
+                local_set(OldHandle(spawner), taskgroup_key!(), group);
                 group
             }
             Some(group) => group
@@ -627,7 +627,7 @@ fn spawn_raw_oldsched(opts: TaskOpts, f: ~fn()) {
                 let group = @TCB(child, child_arc, ancestors,
                                  is_main, notifier);
                 unsafe {
-                    local_set(child, taskgroup_key!(), group);
+                    local_set(OldHandle(child), taskgroup_key!(), group);
                 }
 
                 // Run the child's body.
-- 
cgit 1.4.1-3-g733a5


From 42c0f88232847e97e6cf3578ef197d1942bba44d Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Mon, 22 Apr 2013 17:15:31 -0700
Subject: core::rt: Add unwinding to newsched tasks

---
 src/libcore/rt/io/mod.rs         |  1 +
 src/libcore/rt/local_services.rs | 78 +++++++++++++++++++++++++++++++++++++---
 src/libcore/rt/sched/mod.rs      |  7 +---
 src/libcore/rt/test.rs           | 41 +++++++++++++++++++++
 src/libcore/sys.rs               | 25 ++++++++++---
 src/libcore/task/mod.rs          | 18 ++++++++--
 src/rt/rust_builtin.cpp          | 22 ++++++++++++
 src/rt/rust_upcall.cpp           | 16 +++++++--
 src/rt/rustrt.def.in             |  2 ++
 9 files changed, 190 insertions(+), 20 deletions(-)

(limited to 'src/libcore/task')

diff --git a/src/libcore/rt/io/mod.rs b/src/libcore/rt/io/mod.rs
index d9d6622277f..131743305bc 100644
--- a/src/libcore/rt/io/mod.rs
+++ b/src/libcore/rt/io/mod.rs
@@ -153,6 +153,7 @@ pub mod mem;
 pub mod stdio;
 
 /// Implementations for Option
+#[cfg(not(stage0))] // Requires condition! fixes
 mod option;
 
 /// Basic stream compression. XXX: Belongs with other flate code
diff --git a/src/libcore/rt/local_services.rs b/src/libcore/rt/local_services.rs
index d29e57a17af..fc75a256428 100644
--- a/src/libcore/rt/local_services.rs
+++ b/src/libcore/rt/local_services.rs
@@ -19,7 +19,8 @@
 //! (freestanding rust with local services?).
 
 use prelude::*;
-use libc::c_void;
+use libc::{c_void, uintptr_t};
+use cast::transmute;
 use super::sched::{Task, local_sched};
 use super::local_heap::LocalHeap;
 
@@ -35,7 +36,10 @@ pub struct LocalServices {
 pub struct GarbageCollector;
 pub struct LocalStorage(*c_void, Option<~fn(*c_void)>);
 pub struct Logger;
-pub struct Unwinder;
+
+pub struct Unwinder {
+    unwinding: bool,
+}
 
 impl LocalServices {
     pub fn new() -> LocalServices {
@@ -44,17 +48,28 @@ impl LocalServices {
             gc: GarbageCollector,
             storage: LocalStorage(ptr::null(), None),
             logger: Logger,
-            unwinder: Unwinder,
+            unwinder: Unwinder { unwinding: false },
             destroyed: false
         }
     }
 
+    pub fn run(&mut self, f: &fn()) {
+        // This is just an assertion that `run` was called unsafely
+        // and this instance of LocalServices is still accessible.
+        do borrow_local_services |sched| {
+            assert!(ptr::ref_eq(sched, self));
+        }
+
+        self.unwinder.try(f);
+        self.destroy();
+    }
+
     /// Must be called manually before finalization to clean up
     /// thread-local resources. Some of the routines here expect
     /// LocalServices to be available recursively so this must be
     /// called unsafely, without removing LocalServices from
     /// thread-local-storage.
-    pub fn destroy(&mut self) {
+    fn destroy(&mut self) {
         // This is just an assertion that `destroy` was called unsafely
         // and this instance of LocalServices is still accessible.
         do borrow_local_services |sched| {
@@ -72,6 +87,51 @@ impl Drop for LocalServices {
     fn finalize(&self) { assert!(self.destroyed) }
 }
 
+// Just a sanity check to make sure we are catching a Rust-thrown exception
+static UNWIND_TOKEN: uintptr_t = 839147;
+
+impl Unwinder {
+    pub fn try(&mut self, f: &fn()) {
+        use sys::Closure;
+
+        unsafe {
+            let closure: Closure = transmute(f);
+            let code = transmute(closure.code);
+            let env = transmute(closure.env);
+
+            let token = rust_try(try_fn, code, env);
+            assert!(token == 0 || token == UNWIND_TOKEN);
+        }
+
+        extern fn try_fn(code: *c_void, env: *c_void) {
+            unsafe {
+                let closure: Closure = Closure {
+                    code: transmute(code),
+                    env: transmute(env),
+                };
+                let closure: &fn() = transmute(closure);
+                closure();
+            }
+        }
+
+        extern {
+            #[rust_stack]
+            fn rust_try(f: *u8, code: *c_void, data: *c_void) -> uintptr_t;
+        }
+    }
+
+    pub fn begin_unwind(&mut self) -> ! {
+        self.unwinding = true;
+        unsafe {
+            rust_begin_unwind(UNWIND_TOKEN);
+            return transmute(());
+        }
+        extern {
+            fn rust_begin_unwind(token: uintptr_t);
+        }
+    }
+}
+
 /// Borrow a pointer to the installed local services.
 /// Fails (likely aborting the process) if local services are not available.
 pub fn borrow_local_services(f: &fn(&mut LocalServices)) {
@@ -125,4 +185,14 @@ mod test {
             }
         }
     }
+
+    #[test]
+    fn unwind() {
+        do run_in_newsched_task() {
+            let result = spawn_try(||());
+            assert!(result.is_ok());
+            let result = spawn_try(|| fail!());
+            assert!(result.is_err());
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/libcore/rt/sched/mod.rs b/src/libcore/rt/sched/mod.rs
index b7d861b8946..65456c30fee 100644
--- a/src/libcore/rt/sched/mod.rs
+++ b/src/libcore/rt/sched/mod.rs
@@ -353,15 +353,10 @@ pub impl Task {
             unsafe {
                 let sched = local_sched::unsafe_borrow();
                 sched.run_cleanup_job();
-            }
-
-            start();
 
-            unsafe {
-                // Destroy the local heap, TLS, etc.
                 let sched = local_sched::unsafe_borrow();
                 let task = sched.current_task.get_mut_ref();
-                task.local_services.destroy();
+                task.local_services.run(start);
             }
 
             let sched = local_sched::take();
diff --git a/src/libcore/rt/test.rs b/src/libcore/rt/test.rs
index e394a873fea..f3d73c91bd6 100644
--- a/src/libcore/rt/test.rs
+++ b/src/libcore/rt/test.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use result::{Result, Ok, Err};
 use super::io::net::ip::{IpAddr, Ipv4};
 
 /// Creates a new scheduler in a new thread and runs a task in it,
@@ -47,6 +48,46 @@ pub fn spawn_immediately(f: ~fn()) {
     }
 }
 
+/// Spawn a task and wait for it to finish, returning whether it completed successfully or failed
+pub fn spawn_try(f: ~fn()) -> Result<(), ()> {
+    use cell::Cell;
+    use super::sched::*;
+    use task;
+    use unstable::finally::Finally;
+
+    // Our status variables will be filled in from the scheduler context
+    let mut failed = false;
+    let failed_ptr: *mut bool = &mut failed;
+
+    // Switch to the scheduler
+    let f = Cell(Cell(f));
+    let mut sched = local_sched::take();
+    do sched.deschedule_running_task_and_then() |old_task| {
+        let old_task = Cell(old_task);
+        let f = f.take();
+        let mut sched = local_sched::take();
+        let new_task = ~do Task::new(&mut sched.stack_pool) {
+            do (|| {
+                (f.take())()
+            }).finally {
+                // Check for failure then resume the parent task
+                unsafe { *failed_ptr = task::failing(); }
+                let sched = local_sched::take();
+                do sched.switch_running_tasks_and_then(old_task.take()) |new_task| {
+                    let new_task = Cell(new_task);
+                    do local_sched::borrow |sched| {
+                        sched.task_queue.push_front(new_task.take());
+                    }
+                }
+            }
+        };
+
+        sched.resume_task_immediately(new_task);
+    }
+
+    if !failed { Ok(()) } else { Err(()) }
+}
+
 /// Get a port number, starting at 9600, for use in tests
 pub fn next_test_port() -> u16 {
     unsafe {
diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs
index 04f96f5eb22..c50bc03517f 100644
--- a/src/libcore/sys.rs
+++ b/src/libcore/sys.rs
@@ -134,12 +134,27 @@ pub fn log_str<T>(t: &T) -> ~str {
 
 /** Initiate task failure */
 pub fn begin_unwind(msg: ~str, file: ~str, line: uint) -> ! {
-    do str::as_buf(msg) |msg_buf, _msg_len| {
-        do str::as_buf(file) |file_buf, _file_len| {
+
+    use rt::{context, OldTaskContext};
+    use rt::local_services::unsafe_borrow_local_services;
+
+    match context() {
+        OldTaskContext => {
+            do str::as_buf(msg) |msg_buf, _msg_len| {
+                do str::as_buf(file) |file_buf, _file_len| {
+                    unsafe {
+                        let msg_buf = cast::transmute(msg_buf);
+                        let file_buf = cast::transmute(file_buf);
+                        begin_unwind_(msg_buf, file_buf, line as libc::size_t)
+                    }
+                }
+            }
+        }
+        _ => {
+            gc::cleanup_stack_for_failure();
             unsafe {
-                let msg_buf = cast::transmute(msg_buf);
-                let file_buf = cast::transmute(file_buf);
-                begin_unwind_(msg_buf, file_buf, line as libc::size_t)
+                let local_services = unsafe_borrow_local_services();
+                local_services.unwinder.begin_unwind();
             }
         }
     }
diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs
index a243bfba85c..e1f4805a692 100644
--- a/src/libcore/task/mod.rs
+++ b/src/libcore/task/mod.rs
@@ -558,8 +558,22 @@ pub fn yield() {
 pub fn failing() -> bool {
     //! True if the running task has failed
 
-    unsafe {
-        rt::rust_task_is_unwinding(rt::rust_get_task())
+    use rt::{context, OldTaskContext};
+    use rt::local_services::borrow_local_services;
+
+    match context() {
+        OldTaskContext => {
+            unsafe {
+                rt::rust_task_is_unwinding(rt::rust_get_task())
+            }
+        }
+        _ => {
+            let mut unwinding = false;
+            do borrow_local_services |local| {
+                unwinding = local.unwinder.unwinding;
+            }
+            return unwinding;
+        }
     }
 }
 
diff --git a/src/rt/rust_builtin.cpp b/src/rt/rust_builtin.cpp
index b8749b8f73d..b37644460aa 100644
--- a/src/rt/rust_builtin.cpp
+++ b/src/rt/rust_builtin.cpp
@@ -886,6 +886,28 @@ rust_boxed_region_free(boxed_region *region, rust_opaque_box *box) {
     region->free(box);
 }
 
+typedef void *(rust_try_fn)(void*, void*);
+
+extern "C" CDECL uintptr_t
+rust_try(rust_try_fn f, void *fptr, void *env) {
+    try {
+        f(fptr, env);
+    } catch (uintptr_t token) {
+        assert(token != 0);
+        return token;
+    }
+    return 0;
+}
+
+extern "C" CDECL void
+rust_begin_unwind(uintptr_t token) {
+#ifndef __WIN32__
+    throw token;
+#else
+    abort("failing on win32");
+#endif
+}
+
 //
 // Local Variables:
 // mode: C++
diff --git a/src/rt/rust_upcall.cpp b/src/rt/rust_upcall.cpp
index 9f39e1433fc..34236c36c14 100644
--- a/src/rt/rust_upcall.cpp
+++ b/src/rt/rust_upcall.cpp
@@ -272,7 +272,13 @@ upcall_rust_personality(int version,
     s_rust_personality_args args = {(_Unwind_Reason_Code)0,
                                     version, actions, exception_class,
                                     ue_header, context};
-    rust_task *task = rust_get_current_task();
+    rust_task *task = rust_try_get_current_task();
+
+    if (task == NULL) {
+        // Assuming we're running with the new scheduler
+        upcall_s_rust_personality(&args);
+        return args.retval;
+    }
 
     // The personality function is run on the stack of the
     // last function that threw or landed, which is going
@@ -309,8 +315,12 @@ upcall_del_stack() {
 // needs to acquire the value of the stack pointer
 extern "C" CDECL void
 upcall_reset_stack_limit() {
-    rust_task *task = rust_get_current_task();
-    task->reset_stack_limit();
+    rust_task *task = rust_try_get_current_task();
+    if (task != NULL) {
+        task->reset_stack_limit();
+    } else {
+        // We must be in a newsched task
+    }
 }
 
 //
diff --git a/src/rt/rustrt.def.in b/src/rt/rustrt.def.in
index 9aa80156783..5e9a4b343ee 100644
--- a/src/rt/rustrt.def.in
+++ b/src/rt/rustrt.def.in
@@ -228,3 +228,5 @@ rust_new_boxed_region
 rust_delete_boxed_region
 rust_boxed_region_malloc
 rust_boxed_region_free
+rust_try
+rust_begin_unwind
\ No newline at end of file
-- 
cgit 1.4.1-3-g733a5


From 2a819ae465c5f375df00ead0b3f4c9009da23f25 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 23 Apr 2013 15:11:28 -0700
Subject: core::rt: Tasks to not require an unwinder

A task without an unwinder will abort the process on failure.
I'm using this in the runtime tests to guarantee that a call to
`assert!` actually triggers some kind of failure (an abort)
instead of silently doing nothing. This is essentially in lieu
of a working linked failure implementation.
---
 src/libcore/core.rc              |  3 +++
 src/libcore/macros.rs            | 39 +++++++++++++++++++++++++++++++++++++
 src/libcore/rt/local_services.rs | 30 +++++++++++++++++++++++-----
 src/libcore/rt/mod.rs            | 20 -------------------
 src/libcore/rt/sched/mod.rs      | 10 ++++++++--
 src/libcore/rt/test.rs           | 42 ++++++++++++++++++++++++++++------------
 src/libcore/rt/uvio.rs           | 12 ++++++------
 src/libcore/sys.rs               |  6 +++++-
 src/libcore/task/mod.rs          | 11 ++++++++++-
 9 files changed, 126 insertions(+), 47 deletions(-)
 create mode 100644 src/libcore/macros.rs

(limited to 'src/libcore/task')

diff --git a/src/libcore/core.rc b/src/libcore/core.rc
index e7a5cfbaf4b..a3b2cb4aaf9 100644
--- a/src/libcore/core.rc
+++ b/src/libcore/core.rc
@@ -114,6 +114,9 @@ pub mod linkhack {
     }
 }
 
+// Internal macros
+mod macros;
+
 /* The Prelude. */
 
 pub mod prelude;
diff --git a/src/libcore/macros.rs b/src/libcore/macros.rs
new file mode 100644
index 00000000000..e1276a75e05
--- /dev/null
+++ b/src/libcore/macros.rs
@@ -0,0 +1,39 @@
+// Copyright 2012 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.
+
+#[macro_escape];
+
+// Some basic logging
+macro_rules! rtdebug (
+    ($( $arg:expr),+) => ( {
+        dumb_println(fmt!( $($arg),+ ));
+
+        fn dumb_println(s: &str) {
+            use io::WriterUtil;
+            let dbg = ::libc::STDERR_FILENO as ::io::fd_t;
+            dbg.write_str(s);
+            dbg.write_str("\n");
+        }
+
+    } )
+)
+
+// An alternate version with no output, for turning off logging
+macro_rules! rtdebug_ (
+    ($( $arg:expr),+) => ( $(let _ = $arg)*; )
+)
+
+macro_rules! abort(
+    ($( $msg:expr),+) => ( {
+        rtdebug!($($msg),+);
+
+        unsafe { ::libc::abort(); }
+    } )
+)
diff --git a/src/libcore/rt/local_services.rs b/src/libcore/rt/local_services.rs
index fc75a256428..d09d082c858 100644
--- a/src/libcore/rt/local_services.rs
+++ b/src/libcore/rt/local_services.rs
@@ -29,7 +29,7 @@ pub struct LocalServices {
     gc: GarbageCollector,
     storage: LocalStorage,
     logger: Logger,
-    unwinder: Unwinder,
+    unwinder: Option<Unwinder>,
     destroyed: bool
 }
 
@@ -48,7 +48,18 @@ impl LocalServices {
             gc: GarbageCollector,
             storage: LocalStorage(ptr::null(), None),
             logger: Logger,
-            unwinder: Unwinder { unwinding: false },
+            unwinder: Some(Unwinder { unwinding: false }),
+            destroyed: false
+        }
+    }
+
+    pub fn without_unwinding() -> LocalServices {
+        LocalServices {
+            heap: LocalHeap::new(),
+            gc: GarbageCollector,
+            storage: LocalStorage(ptr::null(), None),
+            logger: Logger,
+            unwinder: None,
             destroyed: false
         }
     }
@@ -60,7 +71,16 @@ impl LocalServices {
             assert!(ptr::ref_eq(sched, self));
         }
 
-        self.unwinder.try(f);
+        match self.unwinder {
+            Some(ref mut unwinder) => {
+                // If there's an unwinder then set up the catch block
+                unwinder.try(f);
+            }
+            None => {
+                // Otherwise, just run the body
+                f()
+            }
+        }
         self.destroy();
     }
 
@@ -189,9 +209,9 @@ mod test {
     #[test]
     fn unwind() {
         do run_in_newsched_task() {
-            let result = spawn_try(||());
+            let result = spawntask_try(||());
             assert!(result.is_ok());
-            let result = spawn_try(|| fail!());
+            let result = spawntask_try(|| fail!());
             assert!(result.is_err());
         }
     }
diff --git a/src/libcore/rt/mod.rs b/src/libcore/rt/mod.rs
index 4a767d61f74..ab89a4c26a5 100644
--- a/src/libcore/rt/mod.rs
+++ b/src/libcore/rt/mod.rs
@@ -12,26 +12,6 @@
 
 use libc::c_char;
 
-// Some basic logging
-macro_rules! rtdebug_ (
-    ($( $arg:expr),+) => ( {
-        dumb_println(fmt!( $($arg),+ ));
-
-        fn dumb_println(s: &str) {
-            use io::WriterUtil;
-            let dbg = ::libc::STDERR_FILENO as ::io::fd_t;
-            dbg.write_str(s);
-            dbg.write_str("\n");
-        }
-
-    } )
-)
-
-// An alternate version with no output, for turning off logging
-macro_rules! rtdebug (
-    ($( $arg:expr),+) => ( $(let _ = $arg)*; )
-)
-
 #[path = "sched/mod.rs"]
 mod sched;
 mod rtio;
diff --git a/src/libcore/rt/sched/mod.rs b/src/libcore/rt/sched/mod.rs
index 65456c30fee..f7b9bd82668 100644
--- a/src/libcore/rt/sched/mod.rs
+++ b/src/libcore/rt/sched/mod.rs
@@ -149,7 +149,7 @@ pub impl Scheduler {
             }
         }
 
-        // Control never reaches here
+        abort!("control reached end of task");
     }
 
     fn schedule_new_task(~self, task: ~Task) {
@@ -333,6 +333,12 @@ pub struct Task {
 
 pub impl Task {
     fn new(stack_pool: &mut StackPool, start: ~fn()) -> Task {
+        Task::with_local(stack_pool, LocalServices::new(), start)
+    }
+
+    fn with_local(stack_pool: &mut StackPool,
+                  local_services: LocalServices,
+                  start: ~fn()) -> Task {
         let start = Task::build_start_wrapper(start);
         let mut stack = stack_pool.take_segment(TASK_MIN_STACK_SIZE);
         // NB: Context holds a pointer to that ~fn
@@ -340,7 +346,7 @@ pub impl Task {
         return Task {
             current_stack_segment: stack,
             saved_context: initial_context,
-            local_services: LocalServices::new()
+            local_services: local_services
         };
     }
 
diff --git a/src/libcore/rt/test.rs b/src/libcore/rt/test.rs
index f3d73c91bd6..f7ba881f84e 100644
--- a/src/libcore/rt/test.rs
+++ b/src/libcore/rt/test.rs
@@ -8,38 +8,56 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use cell::Cell;
 use result::{Result, Ok, Err};
 use super::io::net::ip::{IpAddr, Ipv4};
+use rt::local_services::LocalServices;
 
 /// Creates a new scheduler in a new thread and runs a task in it,
-/// then waits for the scheduler to exit.
+/// then waits for the scheduler to exit. Failure of the task
+/// will abort the process.
 pub fn run_in_newsched_task(f: ~fn()) {
-    use cell::Cell;
     use unstable::run_in_bare_thread;
     use super::sched::Task;
     use super::uvio::UvEventLoop;
 
-    let f = Cell(Cell(f));
+    let f = Cell(f);
 
     do run_in_bare_thread {
         let mut sched = ~UvEventLoop::new_scheduler();
-        let f = f.take();
-        let task = ~do Task::new(&mut sched.stack_pool) {
-            (f.take())();
-        };
+        let task = ~Task::with_local(&mut sched.stack_pool,
+                                     LocalServices::without_unwinding(),
+                                     f.take());
         sched.task_queue.push_back(task);
         sched.run();
     }
 }
 
-/// Create a new task and run it right now
-pub fn spawn_immediately(f: ~fn()) {
-    use cell::Cell;
+/// Test tasks will abort on failure instead of unwinding
+pub fn spawntask(f: ~fn()) {
+    use super::*;
+    use super::sched::*;
+
+    let mut sched = local_sched::take();
+    let task = ~Task::with_local(&mut sched.stack_pool,
+                                 LocalServices::without_unwinding(),
+                                 f);
+    do sched.switch_running_tasks_and_then(task) |task| {
+        let task = Cell(task);
+        let sched = local_sched::take();
+        sched.schedule_new_task(task.take());
+    }
+}
+
+/// Create a new task and run it right now. Aborts on failure
+pub fn spawntask_immediately(f: ~fn()) {
     use super::*;
     use super::sched::*;
 
     let mut sched = local_sched::take();
-    let task = ~Task::new(&mut sched.stack_pool, f);
+    let task = ~Task::with_local(&mut sched.stack_pool,
+                                 LocalServices::without_unwinding(),
+                                 f);
     do sched.switch_running_tasks_and_then(task) |task| {
         let task = Cell(task);
         do local_sched::borrow |sched| {
@@ -49,7 +67,7 @@ pub fn spawn_immediately(f: ~fn()) {
 }
 
 /// Spawn a task and wait for it to finish, returning whether it completed successfully or failed
-pub fn spawn_try(f: ~fn()) -> Result<(), ()> {
+pub fn spawntask_try(f: ~fn()) -> Result<(), ()> {
     use cell::Cell;
     use super::sched::*;
     use task;
diff --git a/src/libcore/rt/uvio.rs b/src/libcore/rt/uvio.rs
index e7b2880b74b..4cceb048cbc 100644
--- a/src/libcore/rt/uvio.rs
+++ b/src/libcore/rt/uvio.rs
@@ -350,7 +350,7 @@ fn test_simple_tcp_server_and_client() {
         let addr = next_test_ip4();
 
         // Start the server first so it's listening when we connect
-        do spawn_immediately {
+        do spawntask_immediately {
             unsafe {
                 let io = local_sched::unsafe_borrow_io();
                 let mut listener = io.bind(addr).unwrap();
@@ -367,7 +367,7 @@ fn test_simple_tcp_server_and_client() {
             }
         }
 
-        do spawn_immediately {
+        do spawntask_immediately {
             unsafe {
                 let io = local_sched::unsafe_borrow_io();
                 let mut stream = io.connect(addr).unwrap();
@@ -383,7 +383,7 @@ fn test_read_and_block() {
     do run_in_newsched_task {
         let addr = next_test_ip4();
 
-        do spawn_immediately {
+        do spawntask_immediately {
             let io = unsafe { local_sched::unsafe_borrow_io() };
             let mut listener = io.bind(addr).unwrap();
             let mut stream = listener.listen().unwrap();
@@ -421,7 +421,7 @@ fn test_read_and_block() {
             listener.close();
         }
 
-        do spawn_immediately {
+        do spawntask_immediately {
             let io = unsafe { local_sched::unsafe_borrow_io() };
             let mut stream = io.connect(addr).unwrap();
             stream.write([0, 1, 2, 3, 4, 5, 6, 7]);
@@ -440,7 +440,7 @@ fn test_read_read_read() {
         let addr = next_test_ip4();
         static MAX: uint = 500000;
         
-        do spawn_immediately {
+        do spawntask_immediately {
             unsafe {
                 let io = local_sched::unsafe_borrow_io();
                 let mut listener = io.bind(addr).unwrap();
@@ -456,7 +456,7 @@ fn test_read_read_read() {
             }
         }
 
-        do spawn_immediately {
+        do spawntask_immediately {
             let io = unsafe { local_sched::unsafe_borrow_io() };
             let mut stream = io.connect(addr).unwrap();
             let mut buf = [0, .. 2048];
diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs
index c50bc03517f..2c3670ad498 100644
--- a/src/libcore/sys.rs
+++ b/src/libcore/sys.rs
@@ -10,6 +10,7 @@
 
 //! Misc low level stuff
 
+use option::{Some, None};
 use cast;
 use cmp::{Eq, Ord};
 use gc;
@@ -154,7 +155,10 @@ pub fn begin_unwind(msg: ~str, file: ~str, line: uint) -> ! {
             gc::cleanup_stack_for_failure();
             unsafe {
                 let local_services = unsafe_borrow_local_services();
-                local_services.unwinder.begin_unwind();
+                match local_services.unwinder {
+                    Some(ref mut unwinder) => unwinder.begin_unwind(),
+                    None => abort!("failure without unwinder. aborting process")
+                }
             }
         }
     }
diff --git a/src/libcore/task/mod.rs b/src/libcore/task/mod.rs
index e1f4805a692..d31a511eca8 100644
--- a/src/libcore/task/mod.rs
+++ b/src/libcore/task/mod.rs
@@ -570,7 +570,16 @@ pub fn failing() -> bool {
         _ => {
             let mut unwinding = false;
             do borrow_local_services |local| {
-                unwinding = local.unwinder.unwinding;
+                unwinding = match local.unwinder {
+                    Some(unwinder) => {
+                        unwinder.unwinding
+                    }
+                    None => {
+                        // Because there is no unwinder we can't be unwinding.
+                        // (The process will abort on failure)
+                        false
+                    }
+                }
             }
             return unwinding;
         }
-- 
cgit 1.4.1-3-g733a5


From 6373861510795bcaa6e98e97942c32eb26263bd8 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Tue, 23 Apr 2013 19:52:16 -0700
Subject: core: Convert reinterpret_cast to transmute in TLS. #6039

---
 src/libcore/task/local_data_priv.rs | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

(limited to 'src/libcore/task')

diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs
index 66808bf21aa..e32d18719bd 100644
--- a/src/libcore/task/local_data_priv.rs
+++ b/src/libcore/task/local_data_priv.rs
@@ -49,8 +49,8 @@ impl<T:Durable> LocalData for @T { }
 impl Eq for @LocalData {
     fn eq(&self, other: &@LocalData) -> bool {
         unsafe {
-            let ptr_a: (uint, uint) = cast::reinterpret_cast(&(*self));
-            let ptr_b: (uint, uint) = cast::reinterpret_cast(other);
+            let ptr_a: &(uint, uint) = cast::transmute(self);
+            let ptr_b: &(uint, uint) = cast::transmute(other);
             return ptr_a == ptr_b;
         }
     }
@@ -68,7 +68,7 @@ fn cleanup_task_local_map(map_ptr: *libc::c_void) {
         assert!(!map_ptr.is_null());
         // Get and keep the single reference that was created at the
         // beginning.
-        let _map: TaskLocalMap = cast::reinterpret_cast(&map_ptr);
+        let _map: TaskLocalMap = cast::transmute(map_ptr);
         // All local_data will be destroyed along with the map.
     }
 }
@@ -125,14 +125,9 @@ unsafe fn get_newsched_local_map(local: *mut LocalStorage) -> TaskLocalMap {
         &LocalStorage(ref mut map_ptr, ref mut at_exit) => {
             assert!((*map_ptr).is_null());
             let map: TaskLocalMap = @mut ~[];
-            // Use reinterpret_cast -- transmute would take map away from us also.
-            *map_ptr = cast::reinterpret_cast(&map);
+            *map_ptr = cast::transmute(map);
             let at_exit_fn: ~fn(*libc::c_void) = |p|cleanup_task_local_map(p);
             *at_exit = Some(at_exit_fn);
-            // Also need to reference it an extra time to keep it for now.
-            let nonmut = cast::transmute::<TaskLocalMap,
-            @~[Option<TaskLocalElement>]>(map);
-            cast::bump_box_refcount(nonmut);
             return map;
         }
     }
@@ -143,7 +138,7 @@ unsafe fn key_to_key_value<T:Durable>(
 
     // Keys are closures, which are (fnptr,envptr) pairs. Use fnptr.
     // Use reintepret_cast -- transmute would leak (forget) the closure.
-    let pair: (*libc::c_void, *libc::c_void) = cast::reinterpret_cast(&key);
+    let pair: (*libc::c_void, *libc::c_void) = cast::transmute(key);
     pair.first()
 }
 
@@ -213,7 +208,7 @@ pub unsafe fn local_set<T:Durable>(
     // own on it can be dropped when the box is destroyed. The unsafe pointer
     // does not have a reference associated with it, so it may become invalid
     // when the box is destroyed.
-    let data_ptr = cast::reinterpret_cast(&data);
+    let data_ptr = *cast::transmute::<&@T, &*libc::c_void>(&data);
     let data_box = @data as @LocalData;
     // Construct new entry to store in the map.
     let new_entry = Some((keyval, data_ptr, data_box));
-- 
cgit 1.4.1-3-g733a5


From 1962803854bcf7245013f8a1377c0ade845b5c54 Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Wed, 24 Apr 2013 12:11:33 -0700
Subject: core: Warning police

---
 src/libcore/condition.rs         | 2 ++
 src/libcore/rt/io/file.rs        | 2 +-
 src/libcore/rt/io/net/tcp.rs     | 3 ---
 src/libcore/rt/io/net/udp.rs     | 1 -
 src/libcore/rt/io/net/unix.rs    | 1 -
 src/libcore/rt/local_services.rs | 2 +-
 src/libcore/rt/test.rs           | 2 --
 src/libcore/rt/uvio.rs           | 3 +--
 src/libcore/task/local_data.rs   | 1 -
 9 files changed, 5 insertions(+), 12 deletions(-)

(limited to 'src/libcore/task')

diff --git a/src/libcore/condition.rs b/src/libcore/condition.rs
index c639239981c..1240fe03dd5 100644
--- a/src/libcore/condition.rs
+++ b/src/libcore/condition.rs
@@ -206,10 +206,12 @@ mod test {
             fn test_conditions_are_public() {
                 let mut trapped = false;
                 do sadness::cond.trap(|_| {
+                    trapped = true;
                     0
                 }).in {
                     sadness::cond.raise(0);
                 }
+                assert!(trapped);
             }
         }
     }
diff --git a/src/libcore/rt/io/file.rs b/src/libcore/rt/io/file.rs
index e4fe066a173..85dc180452f 100644
--- a/src/libcore/rt/io/file.rs
+++ b/src/libcore/rt/io/file.rs
@@ -11,7 +11,7 @@
 use prelude::*;
 use super::support::PathLike;
 use super::{Reader, Writer, Seek, Close};
-use super::{IoError, SeekStyle};
+use super::SeekStyle;
 
 /// # XXX
 /// * Ugh, this is ridiculous. What is the best way to represent these options?
diff --git a/src/libcore/rt/io/net/tcp.rs b/src/libcore/rt/io/net/tcp.rs
index d726bae821c..c95b4344fe7 100644
--- a/src/libcore/rt/io/net/tcp.rs
+++ b/src/libcore/rt/io/net/tcp.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use prelude::*;
-use super::*;
 use super::super::*;
 use super::ip::IpAddr;
 
@@ -51,8 +50,6 @@ impl Listener<TcpStream> for TcpListener {
 
 #[cfg(test)]
 mod test {
-    use super::*;
-    use rt::test::*;
 
     #[test] #[ignore]
     fn smoke_test() {
diff --git a/src/libcore/rt/io/net/udp.rs b/src/libcore/rt/io/net/udp.rs
index 8691a697e88..0cb2978fb1a 100644
--- a/src/libcore/rt/io/net/udp.rs
+++ b/src/libcore/rt/io/net/udp.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use prelude::*;
-use super::*;
 use super::super::*;
 use super::ip::IpAddr;
 
diff --git a/src/libcore/rt/io/net/unix.rs b/src/libcore/rt/io/net/unix.rs
index bb3db6ec0d5..262816beecc 100644
--- a/src/libcore/rt/io/net/unix.rs
+++ b/src/libcore/rt/io/net/unix.rs
@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use prelude::*;
-use super::*;
 use super::super::*;
 use super::super::support::PathLike;
 
diff --git a/src/libcore/rt/local_services.rs b/src/libcore/rt/local_services.rs
index 8a6277c2094..a03bc6c409f 100644
--- a/src/libcore/rt/local_services.rs
+++ b/src/libcore/rt/local_services.rs
@@ -21,7 +21,7 @@
 use prelude::*;
 use libc::{c_void, uintptr_t};
 use cast::transmute;
-use super::sched::{Task, local_sched};
+use super::sched::local_sched;
 use super::local_heap::LocalHeap;
 
 pub struct LocalServices {
diff --git a/src/libcore/rt/test.rs b/src/libcore/rt/test.rs
index f7ba881f84e..63db7054088 100644
--- a/src/libcore/rt/test.rs
+++ b/src/libcore/rt/test.rs
@@ -35,7 +35,6 @@ pub fn run_in_newsched_task(f: ~fn()) {
 
 /// Test tasks will abort on failure instead of unwinding
 pub fn spawntask(f: ~fn()) {
-    use super::*;
     use super::sched::*;
 
     let mut sched = local_sched::take();
@@ -51,7 +50,6 @@ pub fn spawntask(f: ~fn()) {
 
 /// Create a new task and run it right now. Aborts on failure
 pub fn spawntask_immediately(f: ~fn()) {
-    use super::*;
     use super::sched::*;
 
     let mut sched = local_sched::take();
diff --git a/src/libcore/rt/uvio.rs b/src/libcore/rt/uvio.rs
index 984ae55399c..94f8c0bf707 100644
--- a/src/libcore/rt/uvio.rs
+++ b/src/libcore/rt/uvio.rs
@@ -11,7 +11,7 @@
 use option::*;
 use result::*;
 
-use super::io::net::ip::{IpAddr, Ipv4}; // n.b. Ipv4 is used only in tests
+use super::io::net::ip::IpAddr;
 use super::uv::*;
 use super::rtio::*;
 use ops::Drop;
@@ -21,7 +21,6 @@ use super::sched::{Scheduler, local_sched};
 
 #[cfg(test)] use uint;
 #[cfg(test)] use unstable::run_in_bare_thread;
-#[cfg(test)] use super::sched::Task;
 #[cfg(test)] use super::test::*;
 
 pub struct UvEventLoop {
diff --git a/src/libcore/task/local_data.rs b/src/libcore/task/local_data.rs
index 65e68931915..dff5908c047 100644
--- a/src/libcore/task/local_data.rs
+++ b/src/libcore/task/local_data.rs
@@ -28,7 +28,6 @@ magic.
 
 use prelude::*;
 use task::local_data_priv::{local_get, local_pop, local_modify, local_set, Handle};
-use task::rt;
 
 /**
  * Indexes a task-local data slot. The function's code pointer is used for
-- 
cgit 1.4.1-3-g733a5


From 436657b5f04a6d7504cfc00224c26910569c67eb Mon Sep 17 00:00:00 2001
From: Brian Anderson <banderson@mozilla.com>
Date: Wed, 24 Apr 2013 15:34:02 -0700
Subject: Rename cleanup_task_local_map_ to cleanup_task_local_map_extern_cb

Per pcwalton's suggestion.
---
 src/libcore/task/local_data_priv.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/libcore/task')

diff --git a/src/libcore/task/local_data_priv.rs b/src/libcore/task/local_data_priv.rs
index e32d18719bd..fdf1fa2a532 100644
--- a/src/libcore/task/local_data_priv.rs
+++ b/src/libcore/task/local_data_priv.rs
@@ -83,7 +83,7 @@ unsafe fn get_local_map(handle: Handle) -> TaskLocalMap {
 
 unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
 
-    extern fn cleanup_task_local_map_(map_ptr: *libc::c_void) {
+    extern fn cleanup_task_local_map_extern_cb(map_ptr: *libc::c_void) {
         cleanup_task_local_map(map_ptr);
     }
 
@@ -97,7 +97,7 @@ unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
         // Use reinterpret_cast -- transmute would take map away from us also.
         rt::rust_set_task_local_data(
             task, cast::transmute(map));
-        rt::rust_task_local_data_atexit(task, cleanup_task_local_map_);
+        rt::rust_task_local_data_atexit(task, cleanup_task_local_map_extern_cb);
         // Also need to reference it an extra time to keep it for now.
         let nonmut = cast::transmute::<TaskLocalMap,
                                        @~[Option<TaskLocalElement>]>(map);
-- 
cgit 1.4.1-3-g733a5