Merge remote-tracking branch 'brson/io'

Conflicts:
	src/libcore/task/local_data_priv.rs

diff --cc src/libcore/core.rc
Simple merge

diff --cc src/libcore/rt/sched/mod.rs
index 28946281628b199044dfbd9c010298560fc949a7,f7b9bd8266844080e0551728560e1dca534afbe1..d7543ae138c40eaa96fe319f0a32169abee4f31d
--- 1/src/libcore/rt/sched/mod.rs
--- 2/src/libcore/rt/sched/mod.rs
+++ b/src/libcore/rt/sched/mod.rs
@@@ -349,9 -359,11 +359,12 @@@ pub impl Task 
              unsafe {
                  let sched = local_sched::unsafe_borrow();
                  sched.run_cleanup_job();
-             }
  
-             start();
+                 let sched = local_sched::unsafe_borrow();
+                 let task = sched.current_task.get_mut_ref();
 -                task.local_services.run(start);
++                // FIXME #6141: shouldn't neet to put `start()` in another closure
++                task.local_services.run(||start());
+             }
  
              let sched = local_sched::take();
              sched.terminate_current_task();

diff --cc src/libcore/rt/uv/mod.rs
Simple merge

diff --cc src/libcore/rt/uvll.rs
Simple merge

diff --cc src/libcore/sys.rs
index 8cad0a22886424be926e7f213d0474e12e691b41,7c2d9dd46c3b34e20aaf33d4f181acf404331814..215fc95f8c7d7b08fe1d51d045db9976a0221e42
--- 1/src/libcore/sys.rs
--- 2/src/libcore/sys.rs
+++ b/src/libcore/sys.rs
@@@ -165,49 -166,32 +166,67 @@@ pub fn log_str<T>(t: &T) -> ~str 
      }
  }
  
 -/** Initiate task failure */
 +/// Trait for initiating task failure.
 +pub trait FailWithCause {
 +    /// Fail the current task, taking ownership of `cause`
 +    fn fail_with(cause: Self, file: &'static str, line: uint) -> !;
 +}
 +
 +impl FailWithCause for ~str {
 +    fn fail_with(cause: ~str, file: &'static str, line: uint) -> ! {
 +        do str::as_buf(cause) |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)
 +                }
 +            }
 +        }
 +    }
 +}
 +
 +impl FailWithCause for &'static str {
 +    fn fail_with(cause: &'static str, file: &'static str, line: uint) -> ! {
 +        do str::as_buf(cause) |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)
 +                }
 +            }
 +        }
 +    }
 +}
 +
 +// NOTE: remove function after snapshot
 +#[cfg(stage0)]
  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();
+                 match local_services.unwinder {
+                     Some(ref mut unwinder) => unwinder.begin_unwind(),
+                     None => abort!("failure without unwinder. aborting process")
+                 }
              }
          }
      }

diff --cc src/libcore/task/local_data_priv.rs
index 67bc3adeb41c0c61f5055c9d3bc4e153d7b799a4,fdf1fa2a532737e1745db97d867eb4d8137b3b7b..10a40887e57928cfe17e27db382c9c42fe920838
--- 1/src/libcore/task/local_data_priv.rs
--- 2/src/libcore/task/local_data_priv.rs
+++ b/src/libcore/task/local_data_priv.rs
@@@ -59,8 -94,10 +94,8 @@@ unsafe fn get_task_local_map(task: *rus
      let map_ptr = rt::rust_get_task_local_data(task);
      if map_ptr.is_null() {
          let map: TaskLocalMap = @mut ~[];
 -        // Use reinterpret_cast -- transmute would take map away from us also.
 -        rt::rust_set_task_local_data(
 -            task, cast::transmute(map));
 +        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);
@@@ -75,10 -112,33 +110,31 @@@
      }
  }
  
 -unsafe fn key_to_key_value<T:Durable>(
 -    key: LocalDataKey<T>) -> *libc::c_void {
 -
+ 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 ~[];
+             *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);
+             return map;
+         }
+     }
+ }
+ 
 +unsafe fn key_to_key_value<T:Durable>(key: LocalDataKey<T>) -> *libc::c_void {
      // 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::transmute(key);
 +    let pair: (*libc::c_void, *libc::c_void) = cast::transmute_copy(&key);
      pair.first()
  }
  

diff --cc src/libcore/task/mod.rs
Simple merge

diff --cc src/libcore/task/spawn.rs
Simple merge

diff --cc src/libcore/unstable/lang.rs
index 611862a79e7e0bb7a4a89f5aa58a9fc0aece3e80,cb3f399f5919ae4fbd774a033b06be4a19fc7e88..d9870f522890a991c7abdbf95e9ae2608e26ee81
--- 1/src/libcore/unstable/lang.rs
--- 2/src/libcore/unstable/lang.rs
+++ b/src/libcore/unstable/lang.rs
@@@ -88,7 -90,8 +90,8 @@@ pub unsafe fn exchange_free(ptr: *c_cha
  
  #[lang="malloc"]
  #[inline(always)]
 -pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char { 
+ #[cfg(stage0)] // For some reason this isn't working on windows in stage0
 +pub unsafe fn local_malloc(td: *c_char, size: uintptr_t) -> *c_char {
      return rustrt::rust_upcall_malloc_noswitch(td, size);
  }
  

diff --cc src/libsyntax/ext/expand.rs
Simple merge

diff --cc src/rt/rust_task.cpp
Simple merge

diff --cc src/rt/rust_upcall.cpp
Simple merge