---

yaml
---
r: 128691
b: refs/heads/try
c: e59fb9e
h: refs/heads/master
i:
  128689: 8a492cc
  128687: bf4af7a
v: v3

Author: brson

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 07d86b46a949a94223da714e35b343243e4ecce4
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a86d9ad15e339ab343a12513f9c90556f677b9ca
-refs/heads/try: 0cdeb15c316c2fbecd7c10a79baa117d5a1c1f00
+refs/heads/try: e59fb9eb628d5c2242568731396259bf02d50768
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/CONTRIBUTING.md

@@ -16,8 +16,7 @@ please do two things:
 
 2. Run the full Rust test suite with the `make check` command.  You're
    not off the hook even if you just stick to documentation; code
-   examples in the docs are tested as well! Although for simple
-   wording or grammar fixes, this is probably unnecessary.
+   examples in the docs are tested as well!
 
 Pull requests will be treated as "review requests", and we will give
 feedback we expect to see corrected on

branches/try/mk/main.mk

@@ -139,6 +139,10 @@ endif
 RUSTFLAGS_STAGE0 += -C prefer-dynamic
 RUSTFLAGS_STAGE1 += -C prefer-dynamic
 
+# Landing pads require a lot of codegen. We can get through bootstrapping faster
+# by not emitting them.
+RUSTFLAGS_STAGE0 += -Z no-landing-pads
+
 # platform-specific auto-configuration
 include $(CFG_SRC_DIR)mk/platform.mk
 

branches/try/src/libcollections/ringbuf.rs

@@ -403,11 +403,11 @@ impl<'a, T> ExactSize<&'a mut T> for MutItems<'a, T> {}
 fn grow<T>(nelts: uint, loptr: &mut uint, elts: &mut Vec<Option<T>>) {
     assert_eq!(nelts, elts.len());
     let lo = *loptr;
-    elts.reserve(nelts * 2);
-    let newlen = elts.capacity();
+    let newlen = nelts * 2;
+    elts.reserve(newlen);
 
     /* fill with None */
-    for _ in range(elts.len(), newlen) {
+    for _ in range(elts.len(), elts.capacity()) {
         elts.push(None);
     }
 
@@ -750,47 +750,6 @@ mod tests {
         assert_eq!(d.len(), 1);
     }
 
-    #[test]
-    fn test_with_capacity_non_power_two() {
-        let mut d3 = RingBuf::with_capacity(3);
-        d3.push(1i);
-
-        // X = None, | = lo
-        // [|1, X, X]
-        assert_eq!(d3.pop_front(), Some(1));
-        // [X, |X, X]
-        assert_eq!(d3.front(), None);
-
-        // [X, |3, X]
-        d3.push(3);
-        // [X, |3, 6]
-        d3.push(6);
-        // [X, X, |6]
-        assert_eq!(d3.pop_front(), Some(3));
-
-        // Pushing the lo past half way point to trigger
-        // the 'B' scenario for growth
-        // [9, X, |6]
-        d3.push(9);
-        // [9, 12, |6]
-        d3.push(12);
-
-        d3.push(15);
-        // There used to be a bug here about how the
-        // RingBuf made growth assumptions about the
-        // underlying Vec which didn't hold and lead
-        // to corruption.
-        // (Vec grows to next power of two)
-        //good- [9, 12, 15, X, X, X, X, |6]
-        //bug-  [15, 12, X, X, X, |6, X, X]
-        assert_eq!(d3.pop_front(), Some(6));
-
-        // Which leads us to the following state which
-        // would be a failure case.
-        //bug-  [15, 12, X, X, X, X, |X, X]
-        assert_eq!(d3.front(), Some(&9));
-    }
-
     #[test]
     fn test_reserve_exact() {
         let mut d = RingBuf::new();

branches/try/src/libcore/num/f32.rs

@@ -293,7 +293,7 @@ impl Float for f32 {
     #[inline]
     fn frac_pi_8() -> f32 { consts::FRAC_PI_8 }
 
-    /// 1.0 / pi
+    /// 1 .0/ pi
     #[inline]
     fn frac_1_pi() -> f32 { consts::FRAC_1_PI }
 

branches/try/src/librustc/back/link.rs

@@ -1400,20 +1400,6 @@ fn link_args(cmd: &mut Command,
         cmd.arg("-Wl,--gc-sections");
     }
 
-    let used_link_args = sess.cstore.get_used_link_args().borrow();
-
-    // Dynamically linked executables can be compiled as position independent if the default
-    // relocation model of position independent code is not changed. This is a requirement to take
-    // advantage of ASLR, as otherwise the functions in the executable are not randomized and can
-    // be used during an exploit of a vulnerability in any code.
-    if sess.targ_cfg.os == abi::OsLinux {
-        let mut args = sess.opts.cg.link_args.iter().chain(used_link_args.iter());
-        if !dylib && sess.opts.cg.relocation_model.as_slice() == "pic" &&
-            !args.any(|x| x.as_slice() == "-static") {
-            cmd.arg("-pie");
-        }
-    }
-
     if sess.targ_cfg.os == abi::OsLinux || sess.targ_cfg.os == abi::OsDragonfly {
         // GNU-style linkers will use this to omit linking to libraries which
         // don't actually fulfill any relocations, but only for libraries which
@@ -1582,7 +1568,9 @@ fn link_args(cmd: &mut Command,
     // Finally add all the linker arguments provided on the command line along
     // with any #[link_args] attributes found inside the crate
     cmd.args(sess.opts.cg.link_args.as_slice());
-    cmd.args(used_link_args.as_slice());
+    for arg in sess.cstore.get_used_link_args().borrow().iter() {
+        cmd.arg(arg.as_slice());
+    }
 }
 
 // # Native library linking