let align = mem::align_of::<T>();
let p = if size == 0 {
- heap::EMPTY as *mut u8
+ mem::align_of::<T>() as *mut u8
} else {
let p = unsafe { heap::allocate(size, align) };
if p.is_null() {
///
/// This preserves the non-null invariant for types like `Box<T>`. The address
/// may overlap with non-zero-size memory allocations.
-pub const EMPTY: *mut () = 0x1 as *mut ();
+#[rustc_deprecated(since = "1.19", reason = "Use Unique/Shared::empty() instead")]
+#[unstable(feature = "heap_api", issue = "27700")]
+pub const EMPTY: *mut () = 1 as *mut ();
/// The allocator for unique pointers.
// This function must not unwind. If it does, MIR trans will fail.
#[inline]
unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
if size == 0 {
- EMPTY as *mut u8
+ align as *mut u8
} else {
let ptr = allocate(size, align);
if ptr.is_null() {
/// involved. This type is excellent for building your own data structures like Vec and VecDeque.
/// In particular:
///
-/// * Produces heap::EMPTY on zero-sized types
-/// * Produces heap::EMPTY on zero-length allocations
+/// * Produces Unique::empty() on zero-sized types
+/// * Produces Unique::empty() on zero-length allocations
/// * Catches all overflows in capacity computations (promotes them to "capacity overflow" panics)
/// * Guards against 32-bit systems allocating more than isize::MAX bytes
/// * Guards against overflowing your length
/// * Aborts on OOM
-/// * Avoids freeing heap::EMPTY
+/// * Avoids freeing Unique::empty()
/// * Contains a ptr::Unique and thus endows the user with all related benefits
///
/// This type does not in anyway inspect the memory that it manages. When dropped it *will*
/// it makes a RawVec with capacity `usize::MAX`. Useful for implementing
/// delayed allocation.
pub fn new() -> Self {
- unsafe {
- // !0 is usize::MAX. This branch should be stripped at compile time.
- let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 };
+ // !0 is usize::MAX. This branch should be stripped at compile time.
+ let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 };
- // heap::EMPTY doubles as "unallocated" and "zero-sized allocation"
- RawVec {
- ptr: Unique::new(heap::EMPTY as *mut T),
- cap: cap,
- }
+ // Unique::empty() doubles as "unallocated" and "zero-sized allocation"
+ RawVec {
+ ptr: Unique::empty(),
+ cap: cap,
}
}
// handles ZSTs and `cap = 0` alike
let ptr = if alloc_size == 0 {
- heap::EMPTY as *mut u8
+ mem::align_of::<T>() as *mut u8
} else {
let align = mem::align_of::<T>();
let ptr = if zeroed {
impl<T> RawVec<T> {
/// Gets a raw pointer to the start of the allocation. Note that this is
- /// heap::EMPTY if `cap = 0` or T is zero-sized. In the former case, you must
+ /// Unique::empty() if `cap = 0` or T is zero-sized. In the former case, you must
/// be careful.
pub fn ptr(&self) -> *mut T {
- self.ptr.ptr()
+ self.ptr.as_ptr()
}
/// Gets the capacity of the allocation.
#![feature(alloc)]
#![feature(core_intrinsics)]
#![feature(dropck_eyepatch)]
-#![feature(heap_api)]
#![feature(generic_param_attrs)]
#![feature(staged_api)]
#![cfg_attr(test, feature(test))]
use std::ptr;
use std::slice;
-use alloc::heap;
use alloc::raw_vec::RawVec;
/// An arena that can hold objects of only one type.
unsafe {
if mem::size_of::<T>() == 0 {
self.ptr.set(intrinsics::arith_offset(self.ptr.get() as *mut u8, 1) as *mut T);
- let ptr = heap::EMPTY as *mut T;
+ let ptr = mem::align_of::<T>() as *mut T;
// Don't drop the object. This `write` is equivalent to `forget`.
ptr::write(ptr, object);
&mut *ptr
#![stable(feature = "rust1", since = "1.0.0")]
use alloc::boxed::Box;
-use alloc::heap::EMPTY;
use alloc::raw_vec::RawVec;
use borrow::ToOwned;
use borrow::Cow;
self.ptr = arith_offset(self.ptr as *const i8, 1) as *mut T;
// Use a non-null pointer value
- Some(ptr::read(EMPTY as *mut T))
+ // (self.ptr might be null because of wrapping)
+ Some(ptr::read(1 as *mut T))
} else {
let old = self.ptr;
self.ptr = self.ptr.offset(1);
self.end = arith_offset(self.end as *const i8, -1) as *mut T;
// Use a non-null pointer value
- Some(ptr::read(EMPTY as *mut T))
+ // (self.end might be null because of wrapping)
+ Some(ptr::read(1 as *mut T))
} else {
self.end = self.end.offset(-1);
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use alloc::heap::{EMPTY, allocate, deallocate};
+use alloc::heap::{allocate, deallocate};
use cmp;
use hash::{BuildHasher, Hash, Hasher};
type HashUint = usize;
const EMPTY_BUCKET: HashUint = 0;
+const EMPTY: usize = 1;
/// Special `Unique<HashUint>` that uses the lower bit of the pointer
/// to expose a boolean tag.