Bump master to 1.21.0

This commit bumps the master branch's version to 1.21.0 and also updates the
bootstrap compiler from the freshly minted beta release.

3 files changed, 69 insertions, 352 deletions

diff --git a/src/liballoc_system/Cargo.toml b/src/liballoc_system/Cargo.toml
index f20be5fdf5f..a725a8608be 100644
--- a/src/liballoc_system/Cargo.toml
+++ b/src/liballoc_system/Cargo.toml
@@ -10,8 +10,6 @@ test = false
 doc = false
 
 [dependencies]
+alloc = { path = "../liballoc" }
 core = { path = "../libcore" }
 libc = { path = "../rustc/libc_shim" }
-
-[target.'cfg(not(stage0))'.dependencies]
-alloc = { path = "../liballoc" }
diff --git a/src/liballoc_system/lib.rs b/src/liballoc_system/lib.rs
index afecfc16f2c..9a7cba21e3c 100644
--- a/src/liballoc_system/lib.rs
+++ b/src/liballoc_system/lib.rs
@@ -16,13 +16,10 @@
             reason = "this library is unlikely to be stabilized in its current \
                       form or name",
             issue = "27783")]
-#![cfg_attr(stage0, allocator)]
-#![cfg_attr(stage0, feature(allocator))]
-#![cfg_attr(stage0, feature(core_intrinsics))]
-#![cfg_attr(not(stage0), feature(global_allocator))]
-#![cfg_attr(not(stage0), feature(allocator_api))]
-#![cfg_attr(not(stage0), feature(alloc))]
-#![cfg_attr(not(stage0), feature(core_intrinsics))]
+#![feature(global_allocator)]
+#![feature(allocator_api)]
+#![feature(alloc)]
+#![feature(core_intrinsics)]
 #![feature(staged_api)]
 #![cfg_attr(any(unix, target_os = "redox"), feature(libc))]
 
@@ -44,90 +41,80 @@ const MIN_ALIGN: usize = 8;
               target_arch = "sparc64")))]
 const MIN_ALIGN: usize = 16;
 
-#[cfg(stage0)]
-pub use old::*;
-#[cfg(stage0)]
-mod old;
+extern crate alloc;
 
-#[cfg(not(stage0))]
-pub use new::System;
-#[cfg(not(stage0))]
-mod new {
-    pub extern crate alloc;
+use self::alloc::heap::{Alloc, AllocErr, Layout, Excess, CannotReallocInPlace};
 
-    use self::alloc::heap::{Alloc, AllocErr, Layout, Excess, CannotReallocInPlace};
+#[unstable(feature = "allocator_api", issue = "32838")]
+pub struct System;
 
-    #[unstable(feature = "allocator_api", issue = "32838")]
-    pub struct System;
-
-    #[unstable(feature = "allocator_api", issue = "32838")]
-    unsafe impl Alloc for System {
-        #[inline]
-        unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
-            (&*self).alloc(layout)
-        }
+#[unstable(feature = "allocator_api", issue = "32838")]
+unsafe impl Alloc for System {
+    #[inline]
+    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
+        (&*self).alloc(layout)
+    }
 
-        #[inline]
-        unsafe fn alloc_zeroed(&mut self, layout: Layout)
-            -> Result<*mut u8, AllocErr>
-        {
-            (&*self).alloc_zeroed(layout)
-        }
+    #[inline]
+    unsafe fn alloc_zeroed(&mut self, layout: Layout)
+        -> Result<*mut u8, AllocErr>
+    {
+        (&*self).alloc_zeroed(layout)
+    }
 
-        #[inline]
-        unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
-            (&*self).dealloc(ptr, layout)
-        }
+    #[inline]
+    unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
+        (&*self).dealloc(ptr, layout)
+    }
 
-        #[inline]
-        unsafe fn realloc(&mut self,
-                          ptr: *mut u8,
-                          old_layout: Layout,
-                          new_layout: Layout) -> Result<*mut u8, AllocErr> {
-            (&*self).realloc(ptr, old_layout, new_layout)
-        }
+    #[inline]
+    unsafe fn realloc(&mut self,
+                      ptr: *mut u8,
+                      old_layout: Layout,
+                      new_layout: Layout) -> Result<*mut u8, AllocErr> {
+        (&*self).realloc(ptr, old_layout, new_layout)
+    }
 
-        fn oom(&mut self, err: AllocErr) -> ! {
-            (&*self).oom(err)
-        }
+    fn oom(&mut self, err: AllocErr) -> ! {
+        (&*self).oom(err)
+    }
 
-        #[inline]
-        fn usable_size(&self, layout: &Layout) -> (usize, usize) {
-            (&self).usable_size(layout)
-        }
+    #[inline]
+    fn usable_size(&self, layout: &Layout) -> (usize, usize) {
+        (&self).usable_size(layout)
+    }
 
-        #[inline]
-        unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, AllocErr> {
-            (&*self).alloc_excess(layout)
-        }
+    #[inline]
+    unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, AllocErr> {
+        (&*self).alloc_excess(layout)
+    }
 
-        #[inline]
-        unsafe fn realloc_excess(&mut self,
-                                 ptr: *mut u8,
-                                 layout: Layout,
-                                 new_layout: Layout) -> Result<Excess, AllocErr> {
-            (&*self).realloc_excess(ptr, layout, new_layout)
-        }
+    #[inline]
+    unsafe fn realloc_excess(&mut self,
+                             ptr: *mut u8,
+                             layout: Layout,
+                             new_layout: Layout) -> Result<Excess, AllocErr> {
+        (&*self).realloc_excess(ptr, layout, new_layout)
+    }
 
-        #[inline]
-        unsafe fn grow_in_place(&mut self,
-                                ptr: *mut u8,
-                                layout: Layout,
-                                new_layout: Layout) -> Result<(), CannotReallocInPlace> {
-            (&*self).grow_in_place(ptr, layout, new_layout)
-        }
+    #[inline]
+    unsafe fn grow_in_place(&mut self,
+                            ptr: *mut u8,
+                            layout: Layout,
+                            new_layout: Layout) -> Result<(), CannotReallocInPlace> {
+        (&*self).grow_in_place(ptr, layout, new_layout)
+    }
 
-        #[inline]
-        unsafe fn shrink_in_place(&mut self,
-                                  ptr: *mut u8,
-                                  layout: Layout,
-                                  new_layout: Layout) -> Result<(), CannotReallocInPlace> {
-            (&*self).shrink_in_place(ptr, layout, new_layout)
-        }
+    #[inline]
+    unsafe fn shrink_in_place(&mut self,
+                              ptr: *mut u8,
+                              layout: Layout,
+                              new_layout: Layout) -> Result<(), CannotReallocInPlace> {
+        (&*self).shrink_in_place(ptr, layout, new_layout)
     }
 }
 
-#[cfg(all(not(stage0), any(unix, target_os = "redox")))]
+#[cfg(any(unix, target_os = "redox"))]
 mod platform {
     extern crate libc;
 
@@ -135,8 +122,8 @@ mod platform {
     use core::ptr;
 
     use MIN_ALIGN;
-    use new::System;
-    use new::alloc::heap::{Alloc, AllocErr, Layout};
+    use System;
+    use alloc::heap::{Alloc, AllocErr, Layout};
 
     #[unstable(feature = "allocator_api", issue = "32838")]
     unsafe impl<'a> Alloc for &'a System {
@@ -272,15 +259,15 @@ mod platform {
     }
 }
 
-#[cfg(all(windows, not(stage0)))]
+#[cfg(windows)]
 #[allow(bad_style)]
 mod platform {
     use core::cmp;
     use core::ptr;
 
     use MIN_ALIGN;
-    use new::System;
-    use new::alloc::heap::{Alloc, AllocErr, Layout, CannotReallocInPlace};
+    use System;
+    use alloc::heap::{Alloc, AllocErr, Layout, CannotReallocInPlace};
 
     type LPVOID = *mut u8;
     type HANDLE = LPVOID;
diff --git a/src/liballoc_system/old.rs b/src/liballoc_system/old.rs
deleted file mode 100644
index 80aa4607594..00000000000
--- a/src/liballoc_system/old.rs
+++ /dev/null
@@ -1,268 +0,0 @@
-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[no_mangle]
-pub unsafe extern fn __rust_alloc(size: usize,
-                                  align: usize,
-                                  err: *mut u8) -> *mut u8 {
-    let p = imp::allocate(size, align);
-    if p.is_null() {
-        __rust_oom(err);
-    }
-    p
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_oom(_err: *const u8) -> ! {
-    ::core::intrinsics::abort()
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_dealloc(ptr: *mut u8,
-                                    size: usize,
-                                    align: usize) {
-    imp::deallocate(ptr, size, align)
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_usable_size(size: usize,
-                                        _align: usize,
-                                        min: *mut usize,
-                                        max: *mut usize) {
-    *min = size;
-    *max = size;
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_realloc(ptr: *mut u8,
-                                    old_size: usize,
-                                    old_align: usize,
-                                    new_size: usize,
-                                    new_align: usize,
-                                    err: *mut u8) -> *mut u8 {
-    if new_align != old_align {
-        __rust_oom(err);
-    }
-    let p = imp::reallocate(ptr, old_size, new_size, new_align);
-    if p.is_null() {
-        __rust_oom(err);
-    }
-    p
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_alloc_zeroed(size: usize,
-                                         align: usize,
-                                         err: *mut u8) -> *mut u8 {
-    let p = imp::allocate_zeroed(size, align);
-    if p.is_null() {
-        __rust_oom(err);
-    }
-    p
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_alloc_excess(_size: usize,
-                                         _align: usize,
-                                         _excess: *mut usize,
-                                         err: *mut u8) -> *mut u8 {
-    __rust_oom(err);
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_realloc_excess(_ptr: *mut u8,
-                                           _old_size: usize,
-                                           _old_align: usize,
-                                           _new_size: usize,
-                                           _new_align: usize,
-                                           _excess: *mut usize,
-                                           err: *mut u8) -> *mut u8 {
-    __rust_oom(err);
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_grow_in_place(_ptr: *mut u8,
-                                          _old_size: usize,
-                                          _old_align: usize,
-                                          _new_size: usize,
-                                          _new_align: usize) -> u8 {
-    0
-}
-
-#[no_mangle]
-pub unsafe extern fn __rust_shrink_in_place(_ptr: *mut u8,
-                                            _old_size: usize,
-                                            _old_align: usize,
-                                            _new_size: usize,
-                                            _new_align: usize) -> u8 {
-    0
-}
-
-#[cfg(any(unix, target_os = "redox"))]
-mod imp {
-    extern crate libc;
-
-    use core::cmp;
-    use core::ptr;
-    use MIN_ALIGN;
-
-    pub unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
-        if align <= MIN_ALIGN {
-            libc::malloc(size as libc::size_t) as *mut u8
-        } else {
-            aligned_malloc(size, align)
-        }
-    }
-
-    #[cfg(any(target_os = "android", target_os = "redox"))]
-    unsafe fn aligned_malloc(size: usize, align: usize) -> *mut u8 {
-        // On android we currently target API level 9 which unfortunately
-        // doesn't have the `posix_memalign` API used below. Instead we use
-        // `memalign`, but this unfortunately has the property on some systems
-        // where the memory returned cannot be deallocated by `free`!
-        //
-        // Upon closer inspection, however, this appears to work just fine with
-        // Android, so for this platform we should be fine to call `memalign`
-        // (which is present in API level 9). Some helpful references could
-        // possibly be chromium using memalign [1], attempts at documenting that
-        // memalign + free is ok [2] [3], or the current source of chromium
-        // which still uses memalign on android [4].
-        //
-        // [1]: https://codereview.chromium.org/10796020/
-        // [2]: https://code.google.com/p/android/issues/detail?id=35391
-        // [3]: https://bugs.chromium.org/p/chromium/issues/detail?id=138579
-        // [4]: https://chromium.googlesource.com/chromium/src/base/+/master/
-        //                                       /memory/aligned_memory.cc
-        libc::memalign(align as libc::size_t, size as libc::size_t) as *mut u8
-    }
-
-    #[cfg(not(any(target_os = "android", target_os = "redox")))]
-    unsafe fn aligned_malloc(size: usize, align: usize) -> *mut u8 {
-        let mut out = ptr::null_mut();
-        let ret = libc::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
-        }
-    }
-
-    pub unsafe fn allocate_zeroed(size: usize, align: usize) -> *mut u8 {
-        if align <= MIN_ALIGN {
-            libc::calloc(size as libc::size_t, 1) as *mut u8
-        } else {
-            let ptr = aligned_malloc(size, align);
-            if !ptr.is_null() {
-                ptr::write_bytes(ptr, 0, size);
-            }
-            ptr
-        }
-    }
-
-    pub unsafe fn reallocate(ptr: *mut u8, old_size: usize, size: usize, align: usize) -> *mut u8 {
-        if align <= MIN_ALIGN {
-            libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
-        } else {
-            let new_ptr = allocate(size, align);
-            if !new_ptr.is_null() {
-                ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
-                deallocate(ptr, old_size, align);
-            }
-            new_ptr
-        }
-    }
-
-    pub unsafe fn deallocate(ptr: *mut u8, _old_size: usize, _align: usize) {
-        libc::free(ptr as *mut libc::c_void)
-    }
-}
-
-#[cfg(windows)]
-#[allow(bad_style)]
-mod imp {
-    use core::cmp::min;
-    use core::ptr::copy_nonoverlapping;
-    use MIN_ALIGN;
-
-    type LPVOID = *mut u8;
-    type HANDLE = LPVOID;
-    type SIZE_T = usize;
-    type DWORD = u32;
-    type BOOL = i32;
-
-    extern "system" {
-        fn GetProcessHeap() -> HANDLE;
-        fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;
-        fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;
-        fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;
-        fn GetLastError() -> DWORD;
-    }
-
-    #[repr(C)]
-    struct Header(*mut u8);
-
-
-    const HEAP_ZERO_MEMORY: DWORD = 0x00000008;
-
-    unsafe fn get_header<'a>(ptr: *mut u8) -> &'a mut Header {
-        &mut *(ptr as *mut Header).offset(-1)
-    }
-
-    unsafe fn align_ptr(ptr: *mut u8, align: usize) -> *mut u8 {
-        let aligned = ptr.offset((align - (ptr as usize & (align - 1))) as isize);
-        *get_header(aligned) = Header(ptr);
-        aligned
-    }
-
-    #[inline]
-    unsafe fn allocate_with_flags(size: usize, align: usize, flags: DWORD) -> *mut u8 {
-        if align <= MIN_ALIGN {
-            HeapAlloc(GetProcessHeap(), flags, size as SIZE_T) as *mut u8
-        } else {
-            let ptr = HeapAlloc(GetProcessHeap(), flags, (size + align) as SIZE_T) as *mut u8;
-            if ptr.is_null() {
-                return ptr;
-            }
-            align_ptr(ptr, align)
-        }
-    }
-
-    pub unsafe fn allocate(size: usize, align: usize) -> *mut u8 {
-        allocate_with_flags(size, align, 0)
-    }
-
-    pub unsafe fn allocate_zeroed(size: usize, align: usize) -> *mut u8 {
-        allocate_with_flags(size, align, HEAP_ZERO_MEMORY)
-    }
-
-    pub unsafe fn reallocate(ptr: *mut u8, old_size: usize, size: usize, align: usize) -> *mut u8 {
-        if align <= MIN_ALIGN {
-            HeapReAlloc(GetProcessHeap(), 0, ptr as LPVOID, size as SIZE_T) as *mut u8
-        } else {
-            let new = allocate(size, align);
-            if !new.is_null() {
-                copy_nonoverlapping(ptr, new, min(size, old_size));
-                deallocate(ptr, old_size, align);
-            }
-            new
-        }
-    }
-
-    pub unsafe fn deallocate(ptr: *mut u8, _old_size: usize, align: usize) {
-        if align <= MIN_ALIGN {
-            let err = HeapFree(GetProcessHeap(), 0, ptr as LPVOID);
-            debug_assert!(err != 0, "Failed to free heap memory: {}", GetLastError());
-        } else {
-            let header = get_header(ptr);
-            let err = HeapFree(GetProcessHeap(), 0, header.0 as LPVOID);
-            debug_assert!(err != 0, "Failed to free heap memory: {}", GetLastError());
-        }
-    }
-}