---

yaml
---
r: 85449
b: refs/heads/dist-snap
c: 418e1eb
h: refs/heads/master
i:
  85447: ba2ff0b
v: v3

Author: lilyball

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: 0983ebe5310d4eb6d289f636f7ed0536c08bbc0e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: a4d171e009813a4fef8aebeb3c6c7759064aafe2
+refs/heads/dist-snap: 418e1ebae6ed543b1a78c3e987d42bf0bf25f310
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/mk/rt.mk

@@ -68,7 +68,9 @@ RUNTIME_CXXS_$(1)_$(2) := \
               rt/sync/rust_thread.cpp \
               rt/rust_builtin.cpp \
               rt/rust_run_program.cpp \
+              rt/rust_env.cpp \
               rt/rust_rng.cpp \
+              rt/rust_stack.cpp \
               rt/rust_upcall.cpp \
               rt/rust_uv.cpp \
               rt/rust_crate_map.cpp \

branches/dist-snap/src/libextra/arc.rs

@@ -762,7 +762,7 @@ mod tests {
                 do 10.times {
                     let tmp = *num;
                     *num = -1;
-                    task::yield();
+                    task::deschedule();
                     *num = tmp + 1;
                 }
                 c.send(());
@@ -913,17 +913,17 @@ mod tests {
             do read_mode.read |state| {
                 // if writer mistakenly got in, make sure it mutates state
                 // before we assert on it
-                do 5.times { task::yield(); }
+                do 5.times { task::deschedule(); }
                 // make sure writer didn't get in.
                 assert!(*state);
             }
         }
     }
     #[test]
     fn test_rw_write_cond_downgrade_read_race() {
-        // Ideally the above test case would have yield statements in it that
+        // Ideally the above test case would have deschedule statements in it that
         // helped to expose the race nearly 100% of the time... but adding
-        // yields in the intuitively-right locations made it even less likely,
+        // deschedules in the intuitively-right locations made it even less likely,
         // and I wasn't sure why :( . This is a mediocre "next best" option.
         do 8.times { test_rw_write_cond_downgrade_read_race_helper() }
     }

branches/dist-snap/src/libextra/sync.rs

@@ -112,7 +112,7 @@ impl<Q:Send> Sem<Q> {
                 }
             }
             // Uncomment if you wish to test for sem races. Not valgrind-friendly.
-            /* do 1000.times { task::yield(); } */
+            /* do 1000.times { task::deschedule(); } */
             // Need to wait outside the exclusive.
             if waiter_nobe.is_some() {
                 let _ = waiter_nobe.unwrap().recv();
@@ -225,7 +225,7 @@ impl<'self> Condvar<'self> {
                 }
             }
 
-            // If yield checks start getting inserted anywhere, we can be
+            // If deschedule checks start getting inserted anywhere, we can be
             // killed before or after enqueueing. Deciding whether to
             // unkillably reacquire the lock needs to happen atomically
             // wrt enqueuing.
@@ -731,11 +731,11 @@ mod tests {
         let s2 = ~s.clone();
         do task::spawn || {
             do s2.access {
-                do 5.times { task::yield(); }
+                do 5.times { task::deschedule(); }
             }
         }
         do s.access {
-            do 5.times { task::yield(); }
+            do 5.times { task::deschedule(); }
         }
     }
     #[test]
@@ -748,7 +748,7 @@ mod tests {
             s2.acquire();
             c.send(());
         }
-        do 5.times { task::yield(); }
+        do 5.times { task::deschedule(); }
         s.release();
         let _ = p.recv();
 
@@ -757,7 +757,7 @@ mod tests {
         let s = ~Semaphore::new(0);
         let s2 = ~s.clone();
         do task::spawn || {
-            do 5.times { task::yield(); }
+            do 5.times { task::deschedule(); }
             s2.release();
             let _ = p.recv();
         }
@@ -800,7 +800,7 @@ mod tests {
                     c.send(());
                 }
                 let _ = p.recv(); // wait for child to come alive
-                do 5.times { task::yield(); } // let the child contend
+                do 5.times { task::deschedule(); } // let the child contend
             }
             let _ = p.recv(); // wait for child to be done
         }
@@ -837,7 +837,7 @@ mod tests {
             do n.times {
                 do m.lock {
                     let oldval = *sharedstate;
-                    task::yield();
+                    task::deschedule();
                     *sharedstate = oldval + 1;
                 }
             }
@@ -948,7 +948,7 @@ mod tests {
             let (p,c) = comm::stream();
             do task::spawn || { // linked
                 let _ = p.recv(); // wait for sibling to get in the mutex
-                task::yield();
+                task::deschedule();
                 fail!();
             }
             do m2.lock_cond |cond| {
@@ -1114,7 +1114,7 @@ mod tests {
             do n.times {
                 do lock_rwlock_in_mode(x, mode) {
                     let oldval = *sharedstate;
-                    task::yield();
+                    task::deschedule();
                     *sharedstate = oldval + 1;
                 }
             }

branches/dist-snap/src/librustc/middle/lang_items.rs

@@ -57,27 +57,28 @@ pub enum LangItem {
 
     StrEqFnLangItem,                   // 19
     UniqStrEqFnLangItem,               // 20
-    LogTypeFnLangItem,                 // 21
-    FailFnLangItem,                    // 22
-    FailBoundsCheckFnLangItem,         // 23
-    ExchangeMallocFnLangItem,          // 24
-    ClosureExchangeMallocFnLangItem,   // 25
-    ExchangeFreeFnLangItem,            // 26
-    MallocFnLangItem,                  // 27
-    FreeFnLangItem,                    // 28
-    BorrowAsImmFnLangItem,             // 29
-    BorrowAsMutFnLangItem,             // 30
-    ReturnToMutFnLangItem,             // 31
-    CheckNotBorrowedFnLangItem,        // 32
-    StrDupUniqFnLangItem,              // 33
-    RecordBorrowFnLangItem,            // 34
-    UnrecordBorrowFnLangItem,          // 35
-
-    StartFnLangItem,                   // 36
-
-    TyDescStructLangItem,              // 37
-    TyVisitorTraitLangItem,            // 38
-    OpaqueStructLangItem,              // 39
+    AnnihilateFnLangItem,              // 21
+    LogTypeFnLangItem,                 // 22
+    FailFnLangItem,                    // 23
+    FailBoundsCheckFnLangItem,         // 24
+    ExchangeMallocFnLangItem,          // 25
+    ClosureExchangeMallocFnLangItem,   // 26
+    ExchangeFreeFnLangItem,            // 27
+    MallocFnLangItem,                  // 28
+    FreeFnLangItem,                    // 29
+    BorrowAsImmFnLangItem,             // 30
+    BorrowAsMutFnLangItem,             // 31
+    ReturnToMutFnLangItem,             // 32
+    CheckNotBorrowedFnLangItem,        // 33
+    StrDupUniqFnLangItem,              // 34
+    RecordBorrowFnLangItem,            // 35
+    UnrecordBorrowFnLangItem,          // 36
+
+    StartFnLangItem,                   // 37
+
+    TyDescStructLangItem,              // 38
+    TyVisitorTraitLangItem,            // 39
+    OpaqueStructLangItem,              // 40
 }
 
 pub struct LanguageItems {
@@ -121,27 +122,28 @@ impl LanguageItems {
 
             19 => "str_eq",
             20 => "uniq_str_eq",
-            21 => "log_type",
-            22 => "fail_",
-            23 => "fail_bounds_check",
-            24 => "exchange_malloc",
-            25 => "closure_exchange_malloc",
-            26 => "exchange_free",
-            27 => "malloc",
-            28 => "free",
-            29 => "borrow_as_imm",
-            30 => "borrow_as_mut",
-            31 => "return_to_mut",
-            32 => "check_not_borrowed",
-            33 => "strdup_uniq",
-            34 => "record_borrow",
-            35 => "unrecord_borrow",
-
-            36 => "start",
-
-            37 => "ty_desc",
-            38 => "ty_visitor",
-            39 => "opaque",
+            21 => "annihilate",
+            22 => "log_type",
+            23 => "fail_",
+            24 => "fail_bounds_check",
+            25 => "exchange_malloc",
+            26 => "closure_exchange_malloc",
+            27 => "exchange_free",
+            28 => "malloc",
+            29 => "free",
+            30 => "borrow_as_imm",
+            31 => "borrow_as_mut",
+            32 => "return_to_mut",
+            33 => "check_not_borrowed",
+            34 => "strdup_uniq",
+            35 => "record_borrow",
+            36 => "unrecord_borrow",
+
+            37 => "start",
+
+            38 => "ty_desc",
+            39 => "ty_visitor",
+            40 => "opaque",
 
             _ => "???"
         }
@@ -224,6 +226,9 @@ impl LanguageItems {
     pub fn uniq_str_eq_fn(&self) -> Option<def_id> {
         self.items[UniqStrEqFnLangItem as uint]
     }
+    pub fn annihilate_fn(&self) -> Option<def_id> {
+        self.items[AnnihilateFnLangItem as uint]
+    }
     pub fn log_type_fn(&self) -> Option<def_id> {
         self.items[LogTypeFnLangItem as uint]
     }
@@ -322,6 +327,7 @@ impl<'self> LanguageItemCollector<'self> {
 
         item_refs.insert(@"str_eq", StrEqFnLangItem as uint);
         item_refs.insert(@"uniq_str_eq", UniqStrEqFnLangItem as uint);
+        item_refs.insert(@"annihilate", AnnihilateFnLangItem as uint);
         item_refs.insert(@"log_type", LogTypeFnLangItem as uint);
         item_refs.insert(@"fail_", FailFnLangItem as uint);
         item_refs.insert(@"fail_bounds_check",

branches/dist-snap/src/librustc/middle/trans/base.rs

@@ -2906,12 +2906,24 @@ pub fn fill_crate_map(ccx: @mut CrateContext, map: ValueRef) {
     }
     subcrates.push(C_int(ccx, 0));
 
+    let llannihilatefn = match ccx.tcx.lang_items.annihilate_fn() {
+        Some(annihilate_def_id) => {
+            if annihilate_def_id.crate == ast::LOCAL_CRATE {
+                get_item_val(ccx, annihilate_def_id.node)
+            } else {
+                let annihilate_fn_type = csearch::get_type(ccx.tcx,
+                                                           annihilate_def_id).ty;
+                trans_external_path(ccx, annihilate_def_id, annihilate_fn_type)
+            }
+        }
+        None => { C_null(Type::i8p()) }
+    };
+
     unsafe {
         let mod_map = create_module_map(ccx);
         llvm::LLVMSetInitializer(map, C_struct(
             [C_i32(1),
-             // FIXME #8431 This used to be the annihilate function, now it's nothing
-             C_null(Type::i8p()),
+             lib::llvm::llvm::LLVMConstPointerCast(llannihilatefn, Type::i8p().to_ref()),
              p2i(ccx, mod_map),
              C_array(ccx.int_type, subcrates)]));
     }

branches/dist-snap/src/libstd/rt/kill.rs

@@ -141,7 +141,7 @@ pub struct Death {
     on_exit:         Option<~fn(bool)>,
     // nesting level counter for task::unkillable calls (0 == killable).
     unkillable:      int,
-    // nesting level counter for unstable::atomically calls (0 == can yield).
+    // nesting level counter for unstable::atomically calls (0 == can deschedule).
     wont_sleep:      int,
     // A "spare" handle to the kill flag inside the kill handle. Used during
     // blocking/waking as an optimization to avoid two xadds on the refcount.
@@ -572,16 +572,16 @@ impl Death {
     }
 
     /// Enter a possibly-nested "atomic" section of code. Just for assertions.
-    /// All calls must be paired with a subsequent call to allow_yield.
+    /// All calls must be paired with a subsequent call to allow_deschedule.
     #[inline]
-    pub fn inhibit_yield(&mut self) {
+    pub fn inhibit_deschedule(&mut self) {
         self.wont_sleep += 1;
     }
 
     /// Exit a possibly-nested "atomic" section of code. Just for assertions.
-    /// All calls must be paired with a preceding call to inhibit_yield.
+    /// All calls must be paired with a preceding call to inhibit_deschedule.
     #[inline]
-    pub fn allow_yield(&mut self) {
+    pub fn allow_deschedule(&mut self) {
         rtassert!(self.wont_sleep != 0);
         self.wont_sleep -= 1;
     }

branches/dist-snap/src/libstd/select.rs

@@ -250,7 +250,7 @@ mod test {
                     let (c2, p3, c4) = x.take();
                     p3.recv();   // handshake parent
                     c4.send(()); // normal receive
-                    task::yield();
+                    task::deschedule();
                     c2.send(()); // select receive
                 }
 
@@ -294,7 +294,7 @@ mod test {
                             if send_on_chans.contains(&i) {
                                 let c = Cell::new(c);
                                 do spawntask_random {
-                                    task::yield();
+                                    task::deschedule();
                                     c.take().send(());
                                 }
                             }