Separate alloc::heap::Alloc trait for stage0 #[global_allocator]

3 files changed, 104 insertions, 5 deletions

diff --git a/src/liballoc/alloc.rs b/src/liballoc/alloc.rs
index 12ee7701903..00a8b2c0e25 100644
--- a/src/liballoc/alloc.rs
+++ b/src/liballoc/alloc.rs
@@ -22,11 +22,6 @@ use core::usize;
 #[doc(inline)]
 pub use core::alloc::*;
 
-#[doc(hidden)]
-pub mod __core {
-    pub use core::*;
-}
-
 extern "Rust" {
     #[allocator]
     #[rustc_allocator_nounwind]
diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs
new file mode 100644
index 00000000000..a44ff04bd1b
--- /dev/null
+++ b/src/liballoc/heap.rs
@@ -0,0 +1,98 @@
+// Copyright 2014-2015 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.
+
+pub use alloc::{Excess, Layout, AllocErr, CannotReallocInPlace};
+use core::alloc::Alloc as CoreAlloc;
+
+#[doc(hidden)]
+pub mod __core {
+    pub use core::*;
+}
+
+/// Compatibility with older versions of #[global_allocator] during bootstrap
+pub unsafe trait Alloc {
+    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr>;
+    unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout);
+    fn oom(&mut self, err: AllocErr) -> !;
+    fn usable_size(&self, layout: &Layout) -> (usize, usize);
+    unsafe fn realloc(&mut self,
+                      ptr: *mut u8,
+                      layout: Layout,
+                      new_layout: Layout) -> Result<*mut u8, AllocErr>;
+    unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<*mut u8, AllocErr>;
+    unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, AllocErr>;
+    unsafe fn realloc_excess(&mut self,
+                             ptr: *mut u8,
+                             layout: Layout,
+                             new_layout: Layout) -> Result<Excess, AllocErr>;
+    unsafe fn grow_in_place(&mut self,
+                            ptr: *mut u8,
+                            layout: Layout,
+                            new_layout: Layout) -> Result<(), CannotReallocInPlace>;
+    unsafe fn shrink_in_place(&mut self,
+                              ptr: *mut u8,
+                              layout: Layout,
+                              new_layout: Layout) -> Result<(), CannotReallocInPlace>;
+}
+
+#[allow(deprecated)]
+unsafe impl<T> Alloc for T where T: CoreAlloc {
+    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
+        CoreAlloc::alloc(self, layout)
+    }
+
+    unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
+        CoreAlloc::dealloc(self, ptr, layout)
+    }
+
+    fn oom(&mut self, err: AllocErr) -> ! {
+        CoreAlloc::oom(self, err)
+    }
+
+    fn usable_size(&self, layout: &Layout) -> (usize, usize) {
+        CoreAlloc::usable_size(self, layout)
+    }
+
+    unsafe fn realloc(&mut self,
+                      ptr: *mut u8,
+                      layout: Layout,
+                      new_layout: Layout) -> Result<*mut u8, AllocErr> {
+        CoreAlloc::realloc(self, ptr, layout, new_layout)
+    }
+
+    unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
+        CoreAlloc::alloc_zeroed(self, layout)
+    }
+
+    unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, AllocErr> {
+        CoreAlloc::alloc_excess(self, layout)
+    }
+
+    unsafe fn realloc_excess(&mut self,
+                             ptr: *mut u8,
+                             layout: Layout,
+                             new_layout: Layout) -> Result<Excess, AllocErr> {
+        CoreAlloc::realloc_excess(self, ptr, layout, new_layout)
+    }
+
+    unsafe fn grow_in_place(&mut self,
+                            ptr: *mut u8,
+                            layout: Layout,
+                            new_layout: Layout) -> Result<(), CannotReallocInPlace> {
+        CoreAlloc::grow_in_place(self, ptr, layout, new_layout)
+    }
+
+    unsafe fn shrink_in_place(&mut self,
+                              ptr: *mut u8,
+                              layout: Layout,
+                              new_layout: Layout) -> Result<(), CannotReallocInPlace> {
+        CoreAlloc::shrink_in_place(self, ptr, layout, new_layout)
+    }
+}
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs
index 066698a71df..f6598fe5e89 100644
--- a/src/liballoc/lib.rs
+++ b/src/liballoc/lib.rs
@@ -153,10 +153,16 @@ pub mod alloc;
 #[unstable(feature = "allocator_api", issue = "32838")]
 #[rustc_deprecated(since = "1.27.0", reason = "module renamed to `alloc`")]
 /// Use the `alloc` module instead.
+#[cfg(not(stage0))]
 pub mod heap {
     pub use alloc::*;
 }
 
+#[unstable(feature = "allocator_api", issue = "32838")]
+#[rustc_deprecated(since = "1.27.0", reason = "module renamed to `alloc`")]
+#[cfg(stage0)]
+pub mod heap;
+
 // Primitive types using the heaps above
 
 // Need to conditionally define the mod from `boxed.rs` to avoid