---

yaml
---
r: 152531
b: refs/heads/try2
c: 9ece051
h: refs/heads/master
i:
  152529: 7b4ec25
  152527: 8079a1b
v: v3

Author: vhbit

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 6d8342f5e9f7093694548e761ee7df4f55243f3f
+refs/heads/try2: 9ece0510b14e6baad0d2c9511dab86919a5379e1
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/.travis.yml

@@ -12,6 +12,7 @@ install:
   - sudo apt-get update -qq
   - sudo apt-get install -qq --force-yes -y llvm-$LLVM_VERSION
     llvm-${LLVM_VERSION}-dev clang-$LLVM_VERSION lldb-$LLVM_VERSION
+    libjemalloc-dev
 
 
 # All of the llvm tools are suffixed with "-$VERS" which we don't want, so
@@ -28,7 +29,7 @@ before_script:
   - ln -nsf /usr/bin/llc-$LLVM_VERSION local-llvm/bin/llc
   - ln -nsf /usr/include/llvm-$LLVM_VERSION local-llvm/include
   - ./configure --disable-optimize-tests --llvm-root=`pwd`/local-llvm
-    --enable-fast-make --enable-clang
+    --enable-fast-make --enable-clang --jemalloc-root=/usr/lib
 
 # Tidy everything up first, then build a few things, and then run a few tests.
 # Note that this is meant to run in a "fairly small" amount of time, so this

branches/try2/configure

@@ -416,6 +416,7 @@ opt mingw-cross 0 "cross-compile for win32 using mingw"
 opt clang 0 "prefer clang to gcc for building the runtime"
 opt ccache 0 "invoke gcc/clang via ccache to reuse object files between builds"
 opt local-rust 0 "use an installed rustc rather than downloading a snapshot"
+opt pax-flags 0 "apply PaX flags to rustc binaries (required for GRSecurity/PaX-patched kernels)"
 opt inject-std-version 1 "inject the current compiler version of libstd into programs"
 opt llvm-static-stdcpp 0 "statically link to libstdc++ for LLVM"
 opt rpath 1 "build rpaths into rustc itself"
@@ -517,6 +518,12 @@ then
     fi
 fi
 
+if [ "$CFG_OSTYPE" = "unknown-linux-gnu" ]
+then
+    probe CFG_PAXCTL           paxctl /sbin/paxctl
+    probe CFG_ZCAT             zcat
+fi
+
 step_msg "looking for target specific programs"
 
 probe CFG_ADB        adb
@@ -539,6 +546,51 @@ then
     fi
 fi
 
+if [ "$CFG_OSTYPE" = "unknown-linux-gnu" ]
+then
+    if [ ! -z "$CFG_ENABLE_PAX_FLAGS" -a -z "$CFG_PAXCTL" ]
+    then
+        err "enabled PaX markings but no paxctl binary found"
+    fi
+
+    if [ -z "$CFG_DISABLE_PAX_FLAGS" ]
+    then
+        # GRSecurity/PaX detection. This can be very flaky.
+        GRSEC_DETECTED=
+
+        # /dev/grsec only exists if CONFIG_GRKERNSEC_NO_RBAC is not set.
+        # /proc/sys/kernel/grsecurity is not available if ÇONFIG_GRKERNSEC_SYSCTL is not set.
+        if [ -e /dev/grsec -o -d /proc/sys/kernel/grsecurity ]
+        then
+            GRSEC_DETECTED=1
+        # /proc/config.gz is normally only available to root, and only if CONFIG_IKCONFIG_PROC has been set.
+        elif [ -r /proc/config.gz -a ! -z "$CFG_ZCAT" ]
+        then
+            if "$CFG_ZCAT" /proc/config.gz | grep --quiet "CONFIG_GRKERNSEC=y"
+            then
+                GRSEC_DETECTED=1
+            fi
+        # Flaky.
+        elif grep --quiet grsec /proc/version
+        then
+            GRSEC_DETECTED=1
+        fi
+
+        if [ ! -z "$GRSEC_DETECTED" ]
+        then
+            step_msg "GRSecurity: yes"
+            if [ ! -z "$CFG_PAXCTL" ]
+            then
+                CFG_ENABLE_PAX_FLAGS=1
+            else
+                warn "GRSecurity kernel detected but no paxctl binary found: not setting CFG_ENABLE_PAX_FLAGS"
+            fi
+        else
+            step_msg "GRSecurity: no"
+        fi
+    fi
+fi
+
 BIN_SUF=
 if [ "$CFG_OSTYPE" = "pc-mingw32" ] || [ "$CFG_OSTYPE" = "w64-mingw32" ]
 then
@@ -890,33 +942,16 @@ then
     msg "git: submodule sync"
     "${CFG_GIT}" submodule sync
 
-    msg "git: submodule init"
-    "${CFG_GIT}" submodule init
-
-    # Disable submodules that we're not using
-    if [ ! -z "${CFG_LLVM_ROOT}" ]; then
-        msg "git: submodule deinit src/llvm"
-        "${CFG_GIT}" submodule deinit src/llvm
-    fi
-    if [ ! -z "${CFG_JEMALLOC_ROOT}" ]; then
-        msg "git: submodule deinit src/jemalloc"
-        "${CFG_GIT}" submodule deinit src/jemalloc
-    fi
-    if [ ! -z "${CFG_LIBUV_ROOT}" ]; then
-        msg "git: submodule deinit src/libuv"
-        "${CFG_GIT}" submodule deinit src/libuv
-    fi
-
     msg "git: submodule update"
-    "${CFG_GIT}" submodule update
+    "${CFG_GIT}" submodule update --init
     need_ok "git failed"
 
     msg "git: submodule foreach sync"
     "${CFG_GIT}" submodule foreach --recursive 'if test -e .gitmodules; then git submodule sync; fi'
     need_ok "git failed"
 
     msg "git: submodule foreach update"
-    "${CFG_GIT}" submodule update --recursive
+    "${CFG_GIT}" submodule update --init --recursive
     need_ok "git failed"
 
     # NB: this is just for the sake of getting the submodule SHA1 values

branches/try2/mk/stage0.mk

@@ -18,6 +18,10 @@ ifdef CFG_ENABLE_LOCAL_RUST
 	$(Q)$(S)src/etc/local_stage0.sh $(CFG_BUILD) $(CFG_LOCAL_RUST_ROOT) rustlib
 else
 	$(Q)$(CFG_PYTHON) $(S)src/etc/get-snapshot.py $(CFG_BUILD) $(SNAPSHOT_FILE)
+ifdef CFG_ENABLE_PAX_FLAGS
+	@$(call E, apply PaX flags: $@)
+	@"$(CFG_PAXCTL)" -cm "$@"
+endif
 endif
 	$(Q)touch $@
 

branches/try2/src/compiler-rt

@@ -1 +1 @@
-Subproject commit ed112ca1e4275e1c5707a898f2bf6164707ba378
+Subproject commit c10fb8630963e858513fbebe86db3648a2246d73

branches/try2/src/compiletest/compiletest.rs

@@ -20,7 +20,14 @@ extern crate test;
 extern crate getopts;
 extern crate green;
 extern crate rustuv;
-#[phase(plugin, link)] extern crate log;
+
+#[cfg(stage0)]
+#[phase(syntax, link)]
+extern crate log;
+
+#[cfg(not(stage0))]
+#[phase(plugin, link)]
+extern crate log;
 
 extern crate regex;
 
@@ -103,7 +110,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
     let matches =
         &match getopts::getopts(args_.as_slice(), groups.as_slice()) {
           Ok(m) => m,
-          Err(f) => fail!("{}", f)
+          Err(f) => fail!("{}", f.to_err_msg())
         };
 
     if matches.opt_present("h") || matches.opt_present("help") {

branches/try2/src/doc/guide-lifetimes.md

@@ -275,10 +275,8 @@ invalidate the pointer `owner_age`.
 
 # Borrowing and enums
 
-The previous example showed that the type system forbids any mutations
-of owned boxed values while they are being borrowed. In general, the type
-system also forbids borrowing a value as mutable if it is already being
-borrowed - either as a mutable reference or an immutable one. This restriction
+The previous example showed that the type system forbids any borrowing
+of owned boxes found in aliasable, mutable memory. This restriction
 prevents pointers from pointing into freed memory. There is one other
 case where the compiler must be very careful to ensure that pointers
 remain valid: pointers into the interior of an `enum`.

branches/try2/src/jemalloc

@@ -1 +1 @@
-Subproject commit 6a96910f2eaea6d2c705bb12379b23576b30d7d5
+Subproject commit 024c67ad651e1a3ca228936c4cfb13a37329baf2

branches/try2/src/liballoc/lib.rs

@@ -70,16 +70,25 @@
 #![no_std]
 #![feature(phase)]
 
+#[cfg(stage0)]
+#[phase(syntax, link)]
+extern crate core;
+
+#[cfg(not(stage0))]
 #[phase(plugin, link)]
 extern crate core;
+
 extern crate libc;
 
+
 // Allow testing this library
 
 #[cfg(test)] extern crate debug;
 #[cfg(test)] extern crate native;
-#[cfg(test)] #[phase(plugin, link)] extern crate std;
-#[cfg(test)] #[phase(plugin, link)] extern crate log;
+#[cfg(test, stage0)] #[phase(syntax, link)] extern crate std;
+#[cfg(test, stage0)] #[phase(syntax, link)] extern crate log;
+#[cfg(test, not(stage0))] #[phase(plugin, link)] extern crate std;
+#[cfg(test, not(stage0))] #[phase(plugin, link)] extern crate log;
 
 // Heaps provided for low-level allocation strategies
 

branches/try2/src/libarena/lib.rs

@@ -406,8 +406,7 @@ impl<T> TypedArenaChunk<T> {
             None => {}
             Some(mut next) => {
                 // We assume that the next chunk is completely filled.
-                let capacity = next.capacity;
-                next.destroy(capacity)
+                next.destroy(next.capacity)
             }
         }
     }

branches/try2/src/libcollections/bitv.rs

@@ -842,7 +842,6 @@ impl cmp::PartialEq for BitvSet {
 }
 
 impl fmt::Show for BitvSet {
-    #[cfg(stage0)]
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(fmt, r"\{"));
         let mut first = true;
@@ -855,19 +854,6 @@ impl fmt::Show for BitvSet {
         }
         write!(fmt, r"\}")
     }
-    #[cfg(not(stage0))]
-    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(fmt, "{{"));
-        let mut first = true;
-        for n in self.iter() {
-            if !first {
-                try!(write!(fmt, ", "));
-            }
-            try!(write!(fmt, "{}", n));
-            first = false;
-        }
-        write!(fmt, "}}")
-    }
 }
 
 impl<S: hash::Writer> hash::Hash<S> for BitvSet {

branches/try2/src/libcollections/lib.rs

@@ -23,15 +23,24 @@
 #![feature(macro_rules, managed_boxes, default_type_params, phase, globs)]
 #![no_std]
 
-#[phase(plugin, link)] extern crate core;
 extern crate alloc;
 
+#[cfg(stage0)]
+#[phase(syntax, link)]
+extern crate core;
+
+#[cfg(not(stage0))]
+#[phase(plugin, link)]
+extern crate core;
+
 #[cfg(test)] extern crate native;
 #[cfg(test)] extern crate test;
 #[cfg(test)] extern crate debug;
 
-#[cfg(test)] #[phase(plugin, link)] extern crate std;
-#[cfg(test)] #[phase(plugin, link)] extern crate log;
+#[cfg(test, stage0)] #[phase(syntax, link)] extern crate std;
+#[cfg(test, stage0)] #[phase(syntax, link)] extern crate log;
+#[cfg(test, not(stage0))] #[phase(plugin, link)] extern crate std;
+#[cfg(test, not(stage0))] #[phase(plugin, link)] extern crate log;
 
 use core::prelude::*;
 

branches/try2/src/libcollections/ringbuf.rs

@@ -66,8 +66,7 @@ impl<T> Deque<T> for RingBuf<T> {
 
     /// Return a mutable reference to the last element in the RingBuf
     fn back_mut<'a>(&'a mut self) -> Option<&'a mut T> {
-        let nelts = self.nelts;
-        if nelts > 0 { Some(self.get_mut(nelts - 1)) } else { None }
+        if self.nelts > 0 { Some(self.get_mut(self.nelts - 1)) } else { None }
     }
 
     /// Remove and return the first element in the RingBuf, or None if it is empty
@@ -419,7 +418,6 @@ impl<T: fmt::Show> fmt::Show for RingBuf<T> {
 mod tests {
     use std::fmt::Show;
     use std::prelude::*;
-    use std::gc::{GC, Gc};
     use test::Bencher;
     use test;
 
@@ -474,10 +472,10 @@ mod tests {
 
     #[test]
     fn test_boxes() {
-        let a: Gc<int> = box(GC) 5;
-        let b: Gc<int> = box(GC) 72;
-        let c: Gc<int> = box(GC) 64;
-        let d: Gc<int> = box(GC) 175;
+        let a: @int = @5;
+        let b: @int = @72;
+        let c: @int = @64;
+        let d: @int = @175;
 
         let mut deq = RingBuf::new();
         assert_eq!(deq.len(), 0);
@@ -622,8 +620,7 @@ mod tests {
 
     #[test]
     fn test_param_at_int() {
-        test_parameterized::<Gc<int>>(box(GC) 5, box(GC) 72,
-                                      box(GC) 64, box(GC) 175);
+        test_parameterized::<@int>(@5, @72, @64, @175);
     }
 
     #[test]

branches/try2/src/libcollections/slice.rs

@@ -2034,16 +2034,6 @@ mod tests {
         assert!(xs == [1,2,0,4,3,0,0,6,5,0]);
     }
 
-    #[test]
-    fn test_get_mut() {
-        let mut v = [0,1,2];
-        assert_eq!(v.get_mut(3), None);
-        v.get_mut(1).map(|e| *e = 7);
-        assert_eq!(v[1], 7);
-        let mut x = 2;
-        assert_eq!(v.get_mut(2), Some(&mut x));
-    }
-
     #[test]
     fn test_mut_chunks() {
         let mut v = [0u8, 1, 2, 3, 4, 5, 6];

branches/try2/src/libcollections/smallintmap.rs

@@ -185,7 +185,6 @@ impl<V:Clone> SmallIntMap<V> {
 }
 
 impl<V: fmt::Show> fmt::Show for SmallIntMap<V> {
-    #[cfg(stage0)]
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         try!(write!(f, r"\{"));
 
@@ -196,17 +195,6 @@ impl<V: fmt::Show> fmt::Show for SmallIntMap<V> {
 
         write!(f, r"\}")
     }
-    #[cfg(not(stage0))]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "{{"));
-
-        for (i, (k, v)) in self.iter().enumerate() {
-            if i != 0 { try!(write!(f, ", ")); }
-            try!(write!(f, "{}: {}", k, *v));
-        }
-
-        write!(f, "}}")
-    }
 }
 
 macro_rules! iterator {