---

yaml
---
r: 152511
b: refs/heads/try2
c: 0188beb
h: refs/heads/master
i:
  152509: dcabf6a
  152507: 362cf92
  152503: bf98088
  152495: a9dabad
  152479: 1d3ab9d
  152447: 0489d45
v: v3

Author: Valentin Tsatskin

[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: 1cde9d8cbb8dca25d381304f999e38e478dc6ba2
+refs/heads/try2: 0188bebbb703baa7d3cc9608196d9cbd7707a1e0
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

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/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/treemap.rs

@@ -761,7 +761,7 @@ pub struct IntersectionItems<'a, T> {
     b: Peekable<&'a T, SetItems<'a, T>>,
 }
 
-/// Lazy iterator producing elements in the set union (in-order)
+/// Lazy iterator producing elements in the set intersection (in-order)
 pub struct UnionItems<'a, T> {
     a: Peekable<&'a T, SetItems<'a, T>>,
     b: Peekable<&'a T, SetItems<'a, T>>,

branches/try2/src/libcore/any.rs

@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Traits for dynamic typing of any `'static` type (through runtime reflection)
+//! Traits for dynamic typing of any type (through runtime reflection)
 //!
 //! This module implements the `Any` trait, which enables dynamic typing
-//! of any `'static` type through runtime reflection.
+//! of any type, through runtime reflection.
 //!
 //! `Any` itself can be used to get a `TypeId`, and has more features when used as a trait object.
 //! As `&Any` (a borrowed trait object), it has the `is` and `as_ref` methods, to test if the
@@ -32,10 +32,8 @@ pub enum Void { }
 // Any trait
 ///////////////////////////////////////////////////////////////////////////////
 
-/// The `Any` trait is implemented by all `'static` types, and can be used for dynamic typing
-///
-/// Every type with no non-`'static` references implements `Any`, so `Any` can be used as a trait
-/// object to emulate the effects dynamic typing.
+/// The `Any` trait is implemented by all types, and can be used as a trait object
+/// for dynamic typing
 pub trait Any {
     /// Get the `TypeId` of `self`
     fn get_type_id(&self) -> TypeId;
@@ -263,14 +261,6 @@ mod tests {
         let s = format!("{}", b);
         assert_eq!(s.as_slice(), "&Any");
     }
-
-    #[test]
-    fn any_fixed_vec() {
-        let test = [0u, ..8];
-        let test = &test as &Any;
-        assert!(test.is::<[uint, ..8]>());
-        assert!(!test.is::<[uint, ..10]>());
-    }
 }
 
 #[cfg(test)]

branches/try2/src/libcore/intrinsics.rs

@@ -307,20 +307,6 @@ extern "rust-intrinsic" {
     /// `forget` is unsafe because the caller is responsible for
     /// ensuring the argument is deallocated already.
     pub fn forget<T>(_: T) -> ();
-
-    /// Unsafely transforms a value of one type into a value of another type.
-    ///
-    /// Both types must have the same size and alignment, and this guarantee
-    /// is enforced at compile-time.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// use std::mem;
-    ///
-    /// let v: &[u8] = unsafe { mem::transmute("L") };
-    /// assert!(v == [76u8]);
-    /// ```
     pub fn transmute<T,U>(e: T) -> U;
 
     /// Returns `true` if a type requires drop glue.

branches/try2/src/libcore/mem.rs

@@ -17,8 +17,6 @@ use ptr;
 use intrinsics;
 use intrinsics::{bswap16, bswap32, bswap64};
 
-pub use intrinsics::transmute;
-
 /// Returns the size of a type in bytes.
 #[inline]
 #[stable]
@@ -414,6 +412,29 @@ pub fn drop<T>(_x: T) { }
 #[stable]
 pub unsafe fn forget<T>(thing: T) { intrinsics::forget(thing) }
 
+/// Unsafely transforms a value of one type into a value of another type.
+///
+/// Both types must have the same size and alignment, and this guarantee is
+/// enforced at compile-time.
+///
+/// # Example
+///
+/// ```rust
+/// use std::mem;
+///
+/// let v: &[u8] = unsafe { mem::transmute("L") };
+/// assert!(v == [76u8]);
+/// ```
+#[inline]
+#[unstable = "this function will be modified to reject invocations of it which \
+              cannot statically prove that T and U are the same size. For \
+              example, this function, as written today, will be rejected in \
+              the future because the size of T and U cannot be statically \
+              known to be the same"]
+pub unsafe fn transmute<T, U>(thing: T) -> U {
+    intrinsics::transmute(thing)
+}
+
 /// Interprets `src` as `&U`, and then reads `src` without moving the contained
 /// value.
 ///

branches/try2/src/libcore/num/int_macros.rs

@@ -113,33 +113,6 @@ mod tests {
         assert!((0b1111001 as $T).count_zeros() == BITS as $T - 5);
     }
 
-    #[test]
-    fn test_swap_bytes() {
-        let n: $T = 0b0101100; assert_eq!(n.swap_bytes().swap_bytes(), n);
-        let n: $T = 0b0100001; assert_eq!(n.swap_bytes().swap_bytes(), n);
-        let n: $T = 0b1111001; assert_eq!(n.swap_bytes().swap_bytes(), n);
-
-        // Swapping these should make no difference
-        let n: $T = 0;   assert_eq!(n.swap_bytes(), n);
-        let n: $T = -1;  assert_eq!(n.swap_bytes(), n);
-    }
-
-    #[test]
-    fn test_rotate() {
-        let n: $T = 0b0101100; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
-        let n: $T = 0b0100001; assert_eq!(n.rotate_left(3).rotate_left(2).rotate_right(5),  n);
-        let n: $T = 0b1111001; assert_eq!(n.rotate_left(6).rotate_right(2).rotate_right(4), n);
-
-        // Rotating these should make no difference
-        //
-        // We test using 124 bits because to ensure that overlong bit shifts do
-        // not cause undefined behaviour. See #10183.
-        let n: $T = 0;   assert_eq!(n.rotate_left(124), n);
-        let n: $T = -1;  assert_eq!(n.rotate_left(124), n);
-        let n: $T = 0;   assert_eq!(n.rotate_right(124), n);
-        let n: $T = -1;  assert_eq!(n.rotate_right(124), n);
-    }
-
     #[test]
     fn test_signed_checked_div() {
         assert!(10i.checked_div(&2) == Some(5));