---

yaml
---
r: 58319
b: refs/heads/auto
c: b05aae2
h: refs/heads/master
i:
  58317: 201cad6
  58315: 61d4b0f
  58311: b67cd4c
  58303: 91f1ef9
v: v3

Author: alexcrichton

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 7652f3ddb8f3c4fd281e6ec0bd8fc0d9b8ed857b
+refs/heads/auto: b05aae2d4151a5985d58758fcd46037fb39a5fb9
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/mk/platform.mk

@@ -247,12 +247,12 @@ AR_mips-unknown-linux-gnu=mips-linux-gnu-ar
 CFG_LIB_NAME_mips-unknown-linux-gnu=lib$(1).so
 CFG_LIB_GLOB_mips-unknown-linux-gnu=lib$(1)-*.so
 CFG_LIB_DSYM_GLOB_mips-unknown-linux-gnu=lib$(1)-*.dylib.dSYM
-CFG_GCCISH_CFLAGS_mips-unknown-linux-gnu := -Wall -g -fPIC -mips32r2 -msoft-float -mabi=32 -mno-compact-eh
+CFG_GCCISH_CFLAGS_mips-unknown-linux-gnu := -Wall -g -fPIC -mips32r2 -msoft-float -mabi=32
 CFG_GCCISH_CXXFLAGS_mips-unknown-linux-gnu := -fno-rtti
 CFG_GCCISH_LINK_FLAGS_mips-unknown-linux-gnu := -shared -fPIC -g -mips32r2 -msoft-float -mabi=32
 CFG_GCCISH_DEF_FLAG_mips-unknown-linux-gnu := -Wl,--export-dynamic,--dynamic-list=
 CFG_GCCISH_PRE_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-whole-archive
-CFG_GCCISH_POST_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-no-whole-archive
+CFG_GCCISH_POST_LIB_FLAGS_mips-unknown-linux-gnu := -Wl,-no-whole-archive -Wl,-znoexecstack
 CFG_DEF_SUFFIX_mips-unknown-linux-gnu := .linux.def
 CFG_INSTALL_NAME_mips-unknown-linux-gnu =
 CFG_LIBUV_LINK_FLAGS_mips-unknown-linux-gnu =

branches/auto/src/libcore/cleanup.rs

@@ -127,6 +127,7 @@ struct AnnihilateStats {
     n_bytes_freed: uint
 }
 
+#[cfg(stage0)]
 unsafe fn each_live_alloc(read_next_before: bool,
                           f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) {
     //! Walks the internal list of allocations
@@ -141,8 +142,8 @@ unsafe fn each_live_alloc(read_next_before: bool,
         let uniq =
             (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
 
-        if ! f(box, uniq) {
-            break
+        if !f(box, uniq) {
+            return;
         }
 
         if read_next_before {
@@ -152,6 +153,33 @@ unsafe fn each_live_alloc(read_next_before: bool,
         }
     }
 }
+#[cfg(not(stage0))]
+unsafe fn each_live_alloc(read_next_before: bool,
+                          f: &fn(box: *mut BoxRepr, uniq: bool) -> bool) -> bool {
+    //! Walks the internal list of allocations
+
+    use managed;
+
+    let task: *Task = transmute(rustrt::rust_get_task());
+    let box = (*task).boxed_region.live_allocs;
+    let mut box: *mut BoxRepr = transmute(copy box);
+    while box != mut_null() {
+        let next_before = transmute(copy (*box).header.next);
+        let uniq =
+            (*box).header.ref_count == managed::raw::RC_MANAGED_UNIQUE;
+
+        if !f(box, uniq) {
+            return false;
+        }
+
+        if read_next_before {
+            box = next_before;
+        } else {
+            box = transmute(copy (*box).header.next);
+        }
+    }
+    return true;
+}
 
 #[cfg(unix)]
 fn debug_mem() -> bool {

branches/auto/src/libcore/condition.rs

@@ -12,7 +12,7 @@
 
 use prelude::*;
 use task;
-use local_data::{local_data_pop, local_data_set};
+use task::local_data::{local_data_pop, local_data_set};
 
 // helper for transmutation, shown below.
 type RustClosure = (int, int);
@@ -24,14 +24,14 @@ pub struct Handler<T, U> {
 
 pub struct Condition<'self, T, U> {
     name: &'static str,
-    key: local_data::LocalDataKey<'self, Handler<T, U>>
+    key: task::local_data::LocalDataKey<'self, Handler<T, U>>
 }
 
 pub impl<'self, T, U> Condition<'self, T, U> {
     fn trap(&'self self, h: &'self fn(T) -> U) -> Trap<'self, T, U> {
         unsafe {
             let p : *RustClosure = ::cast::transmute(&h);
-            let prev = local_data::local_data_get(self.key);
+            let prev = task::local_data::local_data_get(self.key);
             let h = @Handler { handle: *p, prev: prev };
             Trap { cond: self, handler: h }
         }

branches/auto/src/libcore/container.rs

@@ -30,16 +30,32 @@ pub trait Map<K, V>: Mutable {
     fn contains_key(&self, key: &K) -> bool;
 
     // Visits all keys and values
+    #[cfg(stage0)]
     fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool);
+    // Visits all keys and values
+    #[cfg(not(stage0))]
+    fn each<'a>(&'a self, f: &fn(&K, &'a V) -> bool) -> bool;
 
     /// Visit all keys
+    #[cfg(stage0)]
     fn each_key(&self, f: &fn(&K) -> bool);
+    /// Visit all keys
+    #[cfg(not(stage0))]
+    fn each_key(&self, f: &fn(&K) -> bool) -> bool;
 
     /// Visit all values
+    #[cfg(stage0)]
     fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool);
+    /// Visit all values
+    #[cfg(not(stage0))]
+    fn each_value<'a>(&'a self, f: &fn(&'a V) -> bool) -> bool;
 
     /// Iterate over the map and mutate the contained values
+    #[cfg(stage0)]
     fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool);
+    /// Iterate over the map and mutate the contained values
+    #[cfg(not(stage0))]
+    fn mutate_values(&mut self, f: &fn(&K, &mut V) -> bool) -> bool;
 
     /// Return a reference to the value corresponding to the key
     fn find<'a>(&'a self, key: &K) -> Option<&'a V>;
@@ -65,6 +81,7 @@ pub trait Map<K, V>: Mutable {
     fn pop(&mut self, k: &K) -> Option<V>;
 }
 
+#[cfg(stage0)]
 pub trait Set<T>: Mutable {
     /// Return true if the set contains a value
     fn contains(&self, value: &T) -> bool;
@@ -99,3 +116,39 @@ pub trait Set<T>: Mutable {
     /// Visit the values representing the union
     fn union(&self, other: &Self, f: &fn(&T) -> bool);
 }
+
+#[cfg(not(stage0))]
+pub trait Set<T>: Mutable {
+    /// Return true if the set contains a value
+    fn contains(&self, value: &T) -> bool;
+
+    /// Add a value to the set. Return true if the value was not already
+    /// present in the set.
+    fn insert(&mut self, value: T) -> bool;
+
+    /// Remove a value from the set. Return true if the value was
+    /// present in the set.
+    fn remove(&mut self, value: &T) -> bool;
+
+    /// Return true if the set has no elements in common with `other`.
+    /// This is equivalent to checking for an empty intersection.
+    fn is_disjoint(&self, other: &Self) -> bool;
+
+    /// Return true if the set is a subset of another
+    fn is_subset(&self, other: &Self) -> bool;
+
+    /// Return true if the set is a superset of another
+    fn is_superset(&self, other: &Self) -> bool;
+
+    /// Visit the values representing the difference
+    fn difference(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
+
+    /// Visit the values representing the symmetric difference
+    fn symmetric_difference(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
+
+    /// Visit the values representing the intersection
+    fn intersection(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
+
+    /// Visit the values representing the union
+    fn union(&self, other: &Self, f: &fn(&T) -> bool) -> bool;
+}

branches/auto/src/libcore/core

@@ -215,7 +215,6 @@ pub mod trie;
 pub mod task;
 pub mod comm;
 pub mod pipes;
-pub mod local_data;
 
 
 /* Runtime and platform support */
@@ -228,6 +227,7 @@ pub mod rand;
 pub mod run;
 pub mod sys;
 pub mod cast;
+pub mod flate;
 pub mod repr;
 pub mod cleanup;
 pub mod reflect;

branches/auto/src/libcore/core.rc

@@ -15,14 +15,14 @@ Simple compression
 */
 
 use libc;
-use core::libc::{c_void, size_t, c_int};
+use libc::{c_void, size_t, c_int};
 use vec;
 
-#[cfg(test)] use core::rand;
-#[cfg(test)] use core::rand::RngUtil;
+#[cfg(test)] use rand;
+#[cfg(test)] use rand::RngUtil;
 
 pub mod rustrt {
-    use core::libc::{c_int, c_void, size_t};
+    use libc::{c_int, c_void, size_t};
 
     #[link_name = "rustrt"]
     pub extern {

branches/auto/src/libstd/flate.rs renamed to branches/auto/src/libcore/flate.rs

@@ -129,7 +129,7 @@ type Visitor<'self> = &'self fn(root: **Word, tydesc: *Word) -> bool;
 
 // Walks the list of roots for the given safe point, and calls visitor
 // on each root.
-unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
+unsafe fn _walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
     let fp_bytes: *u8 = cast::transmute(fp);
     let sp_meta: *u32 = cast::transmute(sp.sp_meta);
 
@@ -155,7 +155,7 @@ unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
             } else {
                 ptr::null()
             };
-            if !visitor(root, tydesc) { return; }
+            if !visitor(root, tydesc) { return false; }
         }
         sri += 1;
     }
@@ -168,6 +168,16 @@ unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
         }
         rri += 1;
     }
+    return true;
+}
+
+#[cfg(stage0)]
+unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) {
+    _walk_safe_point(fp, sp, visitor);
+}
+#[cfg(not(stage0))]
+unsafe fn walk_safe_point(fp: *Word, sp: SafePoint, visitor: Visitor) -> bool {
+    _walk_safe_point(fp, sp, visitor)
 }
 
 // Is fp contained in segment?
@@ -222,7 +232,7 @@ static need_cleanup:    Memory = exchange_heap | stack;
 
 // Walks stack, searching for roots of the requested type, and passes
 // each root to the visitor.
-unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
+unsafe fn _walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) -> bool {
     let mut segment = rustrt::rust_get_stack_segment();
     let mut last_ret: *Word = ptr::null();
     // To avoid collecting memory used by the GC itself, skip stack
@@ -274,14 +284,14 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
                     // Root is a generic box.
                     let refcount = **root;
                     if mem | task_local_heap != 0 && refcount != -1 {
-                        if !visitor(root, tydesc) { return; }
+                        if !visitor(root, tydesc) { return false; }
                     } else if mem | exchange_heap != 0 && refcount == -1 {
-                        if !visitor(root, tydesc) { return; }
+                        if !visitor(root, tydesc) { return false; }
                     }
                 } else {
                     // Root is a non-immediate.
                     if mem | stack != 0 {
-                        if !visitor(root, tydesc) { return; }
+                        if !visitor(root, tydesc) { return false; }
                     }
                 }
             }
@@ -290,8 +300,17 @@ unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
         }
         reached_sentinel = delay_reached_sentinel;
     }
+    return true;
 }
 
+#[cfg(stage0)]
+unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) {
+    _walk_gc_roots(mem, sentinel, visitor);
+}
+#[cfg(not(stage0))]
+unsafe fn walk_gc_roots(mem: Memory, sentinel: **Word, visitor: Visitor) -> bool {
+    _walk_gc_roots(mem, sentinel, visitor)
+}
 pub fn gc() {
     unsafe {
         // Abort when GC is disabled.