---

yaml
---
r: 158507
b: refs/heads/try
c: 88d7f0a
h: refs/heads/master
i:
  158505: 56c0661
  158503: 4bcfd50
v: v3

Author: cakebaker

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: a0a7ab461283322215f0343cd2b5e66fc19a7bd5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 1b2ad7831f1745bf4a4709a1fa1772afb47c933c
-refs/heads/try: 02c234cc52be6b655822d86f22751d57f1005822
+refs/heads/try: 88d7f0a8daf9c147178e4ea2b1815f6a035ccaa2
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/mk/main.mk

@@ -100,9 +100,7 @@ endif
 CFG_RUSTC_FLAGS := $(RUSTFLAGS)
 CFG_GCCISH_CFLAGS :=
 CFG_GCCISH_LINK_FLAGS :=
-
-# Turn off broken quarantine (see jemalloc/jemalloc#161)
-CFG_JEMALLOC_FLAGS := --disable-fill
+CFG_JEMALLOC_FLAGS :=
 
 ifdef CFG_DISABLE_OPTIMIZE
   $(info cfg: disabling rustc optimization (CFG_DISABLE_OPTIMIZE))

branches/try/src/compiletest/runtest.rs

@@ -627,7 +627,7 @@ fn find_rust_src_root(config: &Config) -> Option<Path> {
     let path_postfix = Path::new("src/etc/lldb_batchmode.py");
 
     while path.pop() {
-        if path.join(&path_postfix).is_file() {
+        if path.join(path_postfix.clone()).is_file() {
             return Some(path);
         }
     }

branches/try/src/doc/guide-testing.md

@@ -287,7 +287,7 @@ The benchmarking runner offers two ways to avoid this. Either, the
 closure that the `iter` method receives can return an arbitrary value
 which forces the optimizer to consider the result used and ensures it
 cannot remove the computation entirely. This could be done for the
-example above by adjusting the `bh.iter` call to
+example above by adjusting the `b.iter` call to
 
 ~~~
 # struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let b = X;

branches/try/src/doc/intro.md

@@ -494,14 +494,14 @@ non-deterministic aspect:
 $ cargo run
    Compiling hello_world v0.0.1 (file:///Users/you/src/hello_world)
      Running `target/hello_world`
-numbers[1] is 3
-numbers[0] is 2
-numbers[2] is 4
+numbers[1] is 2
+numbers[0] is 1
+numbers[2] is 3
 $ cargo run
      Running `target/hello_world`
-numbers[2] is 4
-numbers[1] is 3
-numbers[0] is 2
+numbers[2] is 3
+numbers[1] is 2
+numbers[0] is 1
 ```
 
 Each time, we get a slightly different output, because each thread works in a

branches/try/src/doc/rust.css

@@ -62,10 +62,6 @@ body {
     font-size: 18px;
     color: #333;
     line-height: 1.428571429;
-
-    -webkit-font-feature-settings: "kern", "liga";
-    -moz-font-feature-settings: "kern", "liga";
-    font-feature-settings: "kern", "liga";
 }
 @media (min-width: 768px) {
     body {

branches/try/src/liballoc/heap.rs

@@ -8,13 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use core::ptr::RawPtr;
-
 // FIXME: #13996: mark the `allocate` and `reallocate` return value as `noalias`
 
-/// Return a pointer to `size` bytes of memory aligned to `align`.
-///
-/// On failure, return a null pointer.
+/// Returns a pointer to `size` bytes of memory.
 ///
 /// Behavior is undefined if the requested size is 0 or the alignment is not a
 /// power of 2. The alignment must be no larger than the largest supported page
@@ -24,9 +20,8 @@ pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
     imp::allocate(size, align)
 }
 
-/// Resize the allocation referenced by `ptr` to `size` bytes.
-///
-/// On failure, return a null pointer and leave the original allocation intact.
+/// Extends or shrinks the allocation referenced by `ptr` to `size` bytes of
+/// memory.
 ///
 /// Behavior is undefined if the requested size is 0 or the alignment is not a
 /// power of 2. The alignment must be no larger than the largest supported page
@@ -40,7 +35,8 @@ pub unsafe fn reallocate(ptr: *mut u8, old_size: uint, size: uint, align: uint)
     imp::reallocate(ptr, old_size, size, align)
 }
 
-/// Resize the allocation referenced by `ptr` to `size` bytes.
+/// Extends or shrinks the allocation referenced by `ptr` to `size` bytes of
+/// memory in-place.
 ///
 /// If the operation succeeds, it returns `usable_size(size, align)` and if it
 /// fails (or is a no-op) it returns `usable_size(old_size, align)`.
@@ -99,9 +95,7 @@ unsafe fn exchange_malloc(size: uint, align: uint) -> *mut u8 {
     if size == 0 {
         EMPTY as *mut u8
     } else {
-        let ptr = allocate(size, align);
-        if ptr.is_null() { ::oom() }
-        ptr
+        allocate(size, align)
     }
 }
 
@@ -126,7 +120,7 @@ const MIN_ALIGN: uint = 16;
 #[cfg(jemalloc)]
 mod imp {
     use core::option::{None, Option};
-    use core::ptr::{null_mut, null};
+    use core::ptr::{RawPtr, null_mut, null};
     use core::num::Int;
     use libc::{c_char, c_int, c_void, size_t};
     use super::MIN_ALIGN;
@@ -137,8 +131,10 @@ mod imp {
 
     extern {
         fn je_mallocx(size: size_t, flags: c_int) -> *mut c_void;
-        fn je_rallocx(ptr: *mut c_void, size: size_t, flags: c_int) -> *mut c_void;
-        fn je_xallocx(ptr: *mut c_void, size: size_t, extra: size_t, flags: c_int) -> size_t;
+        fn je_rallocx(ptr: *mut c_void, size: size_t,
+                      flags: c_int) -> *mut c_void;
+        fn je_xallocx(ptr: *mut c_void, size: size_t, extra: size_t,
+                      flags: c_int) -> size_t;
         fn je_sdallocx(ptr: *mut c_void, size: size_t, flags: c_int);
         fn je_nallocx(size: size_t, flags: c_int) -> size_t;
         fn je_malloc_stats_print(write_cb: Option<extern "C" fn(cbopaque: *mut c_void,
@@ -164,13 +160,21 @@ mod imp {
     #[inline]
     pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
         let flags = align_to_flags(align);
-        je_mallocx(size as size_t, flags) as *mut u8
+        let ptr = je_mallocx(size as size_t, flags) as *mut u8;
+        if ptr.is_null() {
+            ::oom()
+        }
+        ptr
     }
 
     #[inline]
     pub unsafe fn reallocate(ptr: *mut u8, _old_size: uint, size: uint, align: uint) -> *mut u8 {
         let flags = align_to_flags(align);
-        je_rallocx(ptr as *mut c_void, size as size_t, flags) as *mut u8
+        let ptr = je_rallocx(ptr as *mut c_void, size as size_t, flags) as *mut u8;
+        if ptr.is_null() {
+            ::oom()
+        }
+        ptr
     }
 
     #[inline]
@@ -203,6 +207,7 @@ mod imp {
 mod imp {
     use core::cmp;
     use core::ptr;
+    use core::ptr::RawPtr;
     use libc;
     use super::MIN_ALIGN;
 
@@ -215,24 +220,31 @@ mod imp {
     #[inline]
     pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
         if align <= MIN_ALIGN {
-            libc::malloc(size as libc::size_t) as *mut u8
+            let ptr = libc::malloc(size as libc::size_t);
+            if ptr.is_null() {
+                ::oom();
+            }
+            ptr as *mut u8
         } else {
             let mut out = 0 as *mut libc::c_void;
             let ret = posix_memalign(&mut out,
                                      align as libc::size_t,
                                      size as libc::size_t);
             if ret != 0 {
-                ptr::null_mut()
-            } else {
-                out as *mut u8
+                ::oom();
             }
+            out as *mut u8
         }
     }
 
     #[inline]
     pub unsafe fn reallocate(ptr: *mut u8, old_size: uint, size: uint, align: uint) -> *mut u8 {
         if align <= MIN_ALIGN {
-            libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
+            let ptr = libc::realloc(ptr as *mut libc::c_void, size as libc::size_t);
+            if ptr.is_null() {
+                ::oom();
+            }
+            ptr as *mut u8
         } else {
             let new_ptr = allocate(size, align);
             ptr::copy_memory(new_ptr, ptr as *const u8, cmp::min(size, old_size));
@@ -264,6 +276,7 @@ mod imp {
 mod imp {
     use libc::{c_void, size_t};
     use libc;
+    use core::ptr::RawPtr;
     use super::MIN_ALIGN;
 
     extern {
@@ -276,18 +289,35 @@ mod imp {
     #[inline]
     pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
         if align <= MIN_ALIGN {
-            libc::malloc(size as size_t) as *mut u8
+            let ptr = libc::malloc(size as size_t);
+            if ptr.is_null() {
+                ::oom();
+            }
+            ptr as *mut u8
         } else {
-            _aligned_malloc(size as size_t, align as size_t) as *mut u8
+            let ptr = _aligned_malloc(size as size_t, align as size_t);
+            if ptr.is_null() {
+                ::oom();
+            }
+            ptr as *mut u8
         }
     }
 
     #[inline]
     pub unsafe fn reallocate(ptr: *mut u8, _old_size: uint, size: uint, align: uint) -> *mut u8 {
         if align <= MIN_ALIGN {
-            libc::realloc(ptr as *mut c_void, size as size_t) as *mut u8
+            let ptr = libc::realloc(ptr as *mut c_void, size as size_t);
+            if ptr.is_null() {
+                ::oom();
+            }
+            ptr as *mut u8
         } else {
-            _aligned_realloc(ptr as *mut c_void, size as size_t, align as size_t) as *mut u8
+            let ptr = _aligned_realloc(ptr as *mut c_void, size as size_t,
+                                       align as size_t);
+            if ptr.is_null() {
+                ::oom();
+            }
+            ptr as *mut u8
         }
     }
 
@@ -318,15 +348,13 @@ mod imp {
 mod test {
     extern crate test;
     use self::test::Bencher;
-    use core::ptr::RawPtr;
     use heap;
 
     #[test]
     fn basic_reallocate_inplace_noop() {
         unsafe {
             let size = 4000;
             let ptr = heap::allocate(size, 8);
-            if ptr.is_null() { ::oom() }
             let ret = heap::reallocate_inplace(ptr, size, size, 8);
             heap::deallocate(ptr, size, 8);
             assert_eq!(ret, heap::usable_size(size, 8));

branches/try/src/liballoc/lib.rs

@@ -11,7 +11,8 @@
 //! # The Rust core allocation library
 //!
 //! This is the lowest level library through which allocation in Rust can be
-//! performed.
+//! performed where the allocation is assumed to succeed. This library will
+//! abort the process when allocation fails.
 //!
 //! This library, like libcore, is not intended for general usage, but rather as
 //! a building block of other libraries. The types and interfaces in this
@@ -94,10 +95,8 @@ pub mod boxed;
 pub mod arc;
 pub mod rc;
 
-/// Common out-of-memory routine
-#[cold]
-#[inline(never)]
-pub fn oom() -> ! {
+/// Common OOM routine used by liballoc
+fn oom() -> ! {
     // FIXME(#14674): This really needs to do something other than just abort
     //                here, but any printing done must be *guaranteed* to not
     //                allocate.

branches/try/src/libarena/lib.rs

@@ -31,8 +31,6 @@
 #![feature(unsafe_destructor)]
 #![allow(missing_docs)]
 
-extern crate alloc;
-
 use std::cell::{Cell, RefCell};
 use std::cmp;
 use std::intrinsics::{TyDesc, get_tydesc};
@@ -388,7 +386,6 @@ impl<T> TypedArenaChunk<T> {
         let size = calculate_size::<T>(capacity);
         let chunk = allocate(size, mem::min_align_of::<TypedArenaChunk<T>>())
                     as *mut TypedArenaChunk<T>;
-        if chunk.is_null() { alloc::oom() }
         (*chunk).next = next;
         (*chunk).capacity = capacity;
         chunk