Rename alloc::Void to alloc::Opaque
This commit is contained in:
parent
ed29777759
commit
f607a3872a
@ -1 +1 @@
|
|||||||
Subproject commit 498ac2997420f7b25f7cd0a3f8202950d8ad93ec
|
Subproject commit 3c56329d1bd9038e5341f1962bcd8d043312a712
|
@ -29,17 +29,17 @@ looks like:
|
|||||||
```rust
|
```rust
|
||||||
#![feature(global_allocator, allocator_api, heap_api)]
|
#![feature(global_allocator, allocator_api, heap_api)]
|
||||||
|
|
||||||
use std::alloc::{GlobalAlloc, System, Layout, Void};
|
use std::alloc::{GlobalAlloc, System, Layout, Opaque};
|
||||||
use std::ptr::NonNull;
|
use std::ptr::NonNull;
|
||||||
|
|
||||||
struct MyAllocator;
|
struct MyAllocator;
|
||||||
|
|
||||||
unsafe impl GlobalAlloc for MyAllocator {
|
unsafe impl GlobalAlloc for MyAllocator {
|
||||||
unsafe fn alloc(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
|
||||||
System.alloc(layout)
|
System.alloc(layout)
|
||||||
}
|
}
|
||||||
|
|
||||||
unsafe fn dealloc(&self, ptr: *mut Void, layout: Layout) {
|
unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) {
|
||||||
System.dealloc(ptr, layout)
|
System.dealloc(ptr, layout)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -76,36 +76,36 @@ pub const Heap: Global = Global;
|
|||||||
|
|
||||||
unsafe impl GlobalAlloc for Global {
|
unsafe impl GlobalAlloc for Global {
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
|
||||||
#[cfg(not(stage0))]
|
#[cfg(not(stage0))]
|
||||||
let ptr = __rust_alloc(layout.size(), layout.align());
|
let ptr = __rust_alloc(layout.size(), layout.align());
|
||||||
#[cfg(stage0)]
|
#[cfg(stage0)]
|
||||||
let ptr = __rust_alloc(layout.size(), layout.align(), &mut 0);
|
let ptr = __rust_alloc(layout.size(), layout.align(), &mut 0);
|
||||||
ptr as *mut Void
|
ptr as *mut Opaque
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn dealloc(&self, ptr: *mut Void, layout: Layout) {
|
unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) {
|
||||||
__rust_dealloc(ptr as *mut u8, layout.size(), layout.align())
|
__rust_dealloc(ptr as *mut u8, layout.size(), layout.align())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn realloc(&self, ptr: *mut Void, layout: Layout, new_size: usize) -> *mut Void {
|
unsafe fn realloc(&self, ptr: *mut Opaque, layout: Layout, new_size: usize) -> *mut Opaque {
|
||||||
#[cfg(not(stage0))]
|
#[cfg(not(stage0))]
|
||||||
let ptr = __rust_realloc(ptr as *mut u8, layout.size(), layout.align(), new_size);
|
let ptr = __rust_realloc(ptr as *mut u8, layout.size(), layout.align(), new_size);
|
||||||
#[cfg(stage0)]
|
#[cfg(stage0)]
|
||||||
let ptr = __rust_realloc(ptr as *mut u8, layout.size(), layout.align(),
|
let ptr = __rust_realloc(ptr as *mut u8, layout.size(), layout.align(),
|
||||||
new_size, layout.align(), &mut 0);
|
new_size, layout.align(), &mut 0);
|
||||||
ptr as *mut Void
|
ptr as *mut Opaque
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Opaque {
|
||||||
#[cfg(not(stage0))]
|
#[cfg(not(stage0))]
|
||||||
let ptr = __rust_alloc_zeroed(layout.size(), layout.align());
|
let ptr = __rust_alloc_zeroed(layout.size(), layout.align());
|
||||||
#[cfg(stage0)]
|
#[cfg(stage0)]
|
||||||
let ptr = __rust_alloc_zeroed(layout.size(), layout.align(), &mut 0);
|
let ptr = __rust_alloc_zeroed(layout.size(), layout.align(), &mut 0);
|
||||||
ptr as *mut Void
|
ptr as *mut Opaque
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
@ -121,27 +121,27 @@ unsafe impl GlobalAlloc for Global {
|
|||||||
|
|
||||||
unsafe impl Alloc for Global {
|
unsafe impl Alloc for Global {
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr> {
|
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
NonNull::new(GlobalAlloc::alloc(self, layout)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::alloc(self, layout)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn dealloc(&mut self, ptr: NonNull<Void>, layout: Layout) {
|
unsafe fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout) {
|
||||||
GlobalAlloc::dealloc(self, ptr.as_ptr(), layout)
|
GlobalAlloc::dealloc(self, ptr.as_ptr(), layout)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn realloc(&mut self,
|
unsafe fn realloc(&mut self,
|
||||||
ptr: NonNull<Void>,
|
ptr: NonNull<Opaque>,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_size: usize)
|
new_size: usize)
|
||||||
-> Result<NonNull<Void>, AllocErr>
|
-> Result<NonNull<Opaque>, AllocErr>
|
||||||
{
|
{
|
||||||
NonNull::new(GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr> {
|
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
NonNull::new(GlobalAlloc::alloc_zeroed(self, layout)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::alloc_zeroed(self, layout)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -178,7 +178,7 @@ pub(crate) unsafe fn box_free<T: ?Sized>(ptr: *mut T) {
|
|||||||
// We do not allocate for Box<T> when T is ZST, so deallocation is also not necessary.
|
// We do not allocate for Box<T> when T is ZST, so deallocation is also not necessary.
|
||||||
if size != 0 {
|
if size != 0 {
|
||||||
let layout = Layout::from_size_align_unchecked(size, align);
|
let layout = Layout::from_size_align_unchecked(size, align);
|
||||||
Global.dealloc(ptr as *mut Void, layout);
|
Global.dealloc(ptr as *mut Opaque, layout);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -518,7 +518,7 @@ impl<T: ?Sized> Arc<T> {
|
|||||||
|
|
||||||
if self.inner().weak.fetch_sub(1, Release) == 1 {
|
if self.inner().weak.fetch_sub(1, Release) == 1 {
|
||||||
atomic::fence(Acquire);
|
atomic::fence(Acquire);
|
||||||
Global.dealloc(self.ptr.as_void(), Layout::for_value(self.ptr.as_ref()))
|
Global.dealloc(self.ptr.as_opaque(), Layout::for_value(self.ptr.as_ref()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -637,7 +637,7 @@ impl<T: Clone> ArcFromSlice<T> for Arc<[T]> {
|
|||||||
let slice = from_raw_parts_mut(self.elems, self.n_elems);
|
let slice = from_raw_parts_mut(self.elems, self.n_elems);
|
||||||
ptr::drop_in_place(slice);
|
ptr::drop_in_place(slice);
|
||||||
|
|
||||||
Global.dealloc(self.mem.as_void(), self.layout.clone());
|
Global.dealloc(self.mem.as_opaque(), self.layout.clone());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1156,7 +1156,7 @@ impl<T: ?Sized> Drop for Weak<T> {
|
|||||||
if self.inner().weak.fetch_sub(1, Release) == 1 {
|
if self.inner().weak.fetch_sub(1, Release) == 1 {
|
||||||
atomic::fence(Acquire);
|
atomic::fence(Acquire);
|
||||||
unsafe {
|
unsafe {
|
||||||
Global.dealloc(self.ptr.as_void(), Layout::for_value(self.ptr.as_ref()))
|
Global.dealloc(self.ptr.as_opaque(), Layout::for_value(self.ptr.as_ref()))
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -249,7 +249,7 @@ impl<K, V> Root<K, V> {
|
|||||||
self.as_mut().as_leaf_mut().parent = ptr::null();
|
self.as_mut().as_leaf_mut().parent = ptr::null();
|
||||||
|
|
||||||
unsafe {
|
unsafe {
|
||||||
Global.dealloc(NonNull::from(top).as_void(), Layout::new::<InternalNode<K, V>>());
|
Global.dealloc(NonNull::from(top).as_opaque(), Layout::new::<InternalNode<K, V>>());
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -435,7 +435,7 @@ impl<K, V> NodeRef<marker::Owned, K, V, marker::Leaf> {
|
|||||||
> {
|
> {
|
||||||
let node = self.node;
|
let node = self.node;
|
||||||
let ret = self.ascend().ok();
|
let ret = self.ascend().ok();
|
||||||
Global.dealloc(node.as_void(), Layout::new::<LeafNode<K, V>>());
|
Global.dealloc(node.as_opaque(), Layout::new::<LeafNode<K, V>>());
|
||||||
ret
|
ret
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -456,7 +456,7 @@ impl<K, V> NodeRef<marker::Owned, K, V, marker::Internal> {
|
|||||||
> {
|
> {
|
||||||
let node = self.node;
|
let node = self.node;
|
||||||
let ret = self.ascend().ok();
|
let ret = self.ascend().ok();
|
||||||
Global.dealloc(node.as_void(), Layout::new::<InternalNode<K, V>>());
|
Global.dealloc(node.as_opaque(), Layout::new::<InternalNode<K, V>>());
|
||||||
ret
|
ret
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1239,12 +1239,12 @@ impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::
|
|||||||
}
|
}
|
||||||
|
|
||||||
Global.dealloc(
|
Global.dealloc(
|
||||||
right_node.node.as_void(),
|
right_node.node.as_opaque(),
|
||||||
Layout::new::<InternalNode<K, V>>(),
|
Layout::new::<InternalNode<K, V>>(),
|
||||||
);
|
);
|
||||||
} else {
|
} else {
|
||||||
Global.dealloc(
|
Global.dealloc(
|
||||||
right_node.node.as_void(),
|
right_node.node.as_opaque(),
|
||||||
Layout::new::<LeafNode<K, V>>(),
|
Layout::new::<LeafNode<K, V>>(),
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
@ -10,7 +10,7 @@
|
|||||||
|
|
||||||
#![allow(deprecated)]
|
#![allow(deprecated)]
|
||||||
|
|
||||||
pub use alloc::{Layout, AllocErr, CannotReallocInPlace, Void};
|
pub use alloc::{Layout, AllocErr, CannotReallocInPlace, Opaque};
|
||||||
use core::alloc::Alloc as CoreAlloc;
|
use core::alloc::Alloc as CoreAlloc;
|
||||||
use core::ptr::NonNull;
|
use core::ptr::NonNull;
|
||||||
|
|
||||||
@ -54,7 +54,7 @@ unsafe impl<T> Alloc for T where T: CoreAlloc {
|
|||||||
}
|
}
|
||||||
|
|
||||||
unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
|
unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
|
||||||
let ptr = NonNull::new_unchecked(ptr as *mut Void);
|
let ptr = NonNull::new_unchecked(ptr as *mut Opaque);
|
||||||
CoreAlloc::dealloc(self, ptr, layout)
|
CoreAlloc::dealloc(self, ptr, layout)
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -70,7 +70,7 @@ unsafe impl<T> Alloc for T where T: CoreAlloc {
|
|||||||
ptr: *mut u8,
|
ptr: *mut u8,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_layout: Layout) -> Result<*mut u8, AllocErr> {
|
new_layout: Layout) -> Result<*mut u8, AllocErr> {
|
||||||
let ptr = NonNull::new_unchecked(ptr as *mut Void);
|
let ptr = NonNull::new_unchecked(ptr as *mut Opaque);
|
||||||
CoreAlloc::realloc(self, ptr, layout, new_layout.size()).map(|ptr| ptr.cast().as_ptr())
|
CoreAlloc::realloc(self, ptr, layout, new_layout.size()).map(|ptr| ptr.cast().as_ptr())
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -87,7 +87,7 @@ unsafe impl<T> Alloc for T where T: CoreAlloc {
|
|||||||
ptr: *mut u8,
|
ptr: *mut u8,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_layout: Layout) -> Result<Excess, AllocErr> {
|
new_layout: Layout) -> Result<Excess, AllocErr> {
|
||||||
let ptr = NonNull::new_unchecked(ptr as *mut Void);
|
let ptr = NonNull::new_unchecked(ptr as *mut Opaque);
|
||||||
CoreAlloc::realloc_excess(self, ptr, layout, new_layout.size())
|
CoreAlloc::realloc_excess(self, ptr, layout, new_layout.size())
|
||||||
.map(|e| Excess(e.0 .cast().as_ptr(), e.1))
|
.map(|e| Excess(e.0 .cast().as_ptr(), e.1))
|
||||||
}
|
}
|
||||||
@ -96,7 +96,7 @@ unsafe impl<T> Alloc for T where T: CoreAlloc {
|
|||||||
ptr: *mut u8,
|
ptr: *mut u8,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_layout: Layout) -> Result<(), CannotReallocInPlace> {
|
new_layout: Layout) -> Result<(), CannotReallocInPlace> {
|
||||||
let ptr = NonNull::new_unchecked(ptr as *mut Void);
|
let ptr = NonNull::new_unchecked(ptr as *mut Opaque);
|
||||||
CoreAlloc::grow_in_place(self, ptr, layout, new_layout.size())
|
CoreAlloc::grow_in_place(self, ptr, layout, new_layout.size())
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -104,7 +104,7 @@ unsafe impl<T> Alloc for T where T: CoreAlloc {
|
|||||||
ptr: *mut u8,
|
ptr: *mut u8,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_layout: Layout) -> Result<(), CannotReallocInPlace> {
|
new_layout: Layout) -> Result<(), CannotReallocInPlace> {
|
||||||
let ptr = NonNull::new_unchecked(ptr as *mut Void);
|
let ptr = NonNull::new_unchecked(ptr as *mut Opaque);
|
||||||
CoreAlloc::shrink_in_place(self, ptr, layout, new_layout.size())
|
CoreAlloc::shrink_in_place(self, ptr, layout, new_layout.size())
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -90,7 +90,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
|||||||
|
|
||||||
// handles ZSTs and `cap = 0` alike
|
// handles ZSTs and `cap = 0` alike
|
||||||
let ptr = if alloc_size == 0 {
|
let ptr = if alloc_size == 0 {
|
||||||
NonNull::<T>::dangling().as_void()
|
NonNull::<T>::dangling().as_opaque()
|
||||||
} else {
|
} else {
|
||||||
let align = mem::align_of::<T>();
|
let align = mem::align_of::<T>();
|
||||||
let result = if zeroed {
|
let result = if zeroed {
|
||||||
@ -310,7 +310,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
|||||||
let new_cap = 2 * self.cap;
|
let new_cap = 2 * self.cap;
|
||||||
let new_size = new_cap * elem_size;
|
let new_size = new_cap * elem_size;
|
||||||
alloc_guard(new_size).expect("capacity overflow");
|
alloc_guard(new_size).expect("capacity overflow");
|
||||||
let ptr_res = self.a.realloc(NonNull::from(self.ptr).as_void(),
|
let ptr_res = self.a.realloc(NonNull::from(self.ptr).as_opaque(),
|
||||||
cur,
|
cur,
|
||||||
new_size);
|
new_size);
|
||||||
match ptr_res {
|
match ptr_res {
|
||||||
@ -369,7 +369,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
|||||||
let new_cap = 2 * self.cap;
|
let new_cap = 2 * self.cap;
|
||||||
let new_size = new_cap * elem_size;
|
let new_size = new_cap * elem_size;
|
||||||
alloc_guard(new_size).expect("capacity overflow");
|
alloc_guard(new_size).expect("capacity overflow");
|
||||||
match self.a.grow_in_place(NonNull::from(self.ptr).as_void(), old_layout, new_size) {
|
match self.a.grow_in_place(NonNull::from(self.ptr).as_opaque(), old_layout, new_size) {
|
||||||
Ok(_) => {
|
Ok(_) => {
|
||||||
// We can't directly divide `size`.
|
// We can't directly divide `size`.
|
||||||
self.cap = new_cap;
|
self.cap = new_cap;
|
||||||
@ -426,7 +426,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
|||||||
let res = match self.current_layout() {
|
let res = match self.current_layout() {
|
||||||
Some(layout) => {
|
Some(layout) => {
|
||||||
debug_assert!(new_layout.align() == layout.align());
|
debug_assert!(new_layout.align() == layout.align());
|
||||||
self.a.realloc(NonNull::from(self.ptr).as_void(), layout, new_layout.size())
|
self.a.realloc(NonNull::from(self.ptr).as_opaque(), layout, new_layout.size())
|
||||||
}
|
}
|
||||||
None => self.a.alloc(new_layout),
|
None => self.a.alloc(new_layout),
|
||||||
};
|
};
|
||||||
@ -535,7 +535,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
|||||||
let res = match self.current_layout() {
|
let res = match self.current_layout() {
|
||||||
Some(layout) => {
|
Some(layout) => {
|
||||||
debug_assert!(new_layout.align() == layout.align());
|
debug_assert!(new_layout.align() == layout.align());
|
||||||
self.a.realloc(NonNull::from(self.ptr).as_void(), layout, new_layout.size())
|
self.a.realloc(NonNull::from(self.ptr).as_opaque(), layout, new_layout.size())
|
||||||
}
|
}
|
||||||
None => self.a.alloc(new_layout),
|
None => self.a.alloc(new_layout),
|
||||||
};
|
};
|
||||||
@ -601,7 +601,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
|||||||
// FIXME: may crash and burn on over-reserve
|
// FIXME: may crash and burn on over-reserve
|
||||||
alloc_guard(new_layout.size()).expect("capacity overflow");
|
alloc_guard(new_layout.size()).expect("capacity overflow");
|
||||||
match self.a.grow_in_place(
|
match self.a.grow_in_place(
|
||||||
NonNull::from(self.ptr).as_void(), old_layout, new_layout.size(),
|
NonNull::from(self.ptr).as_opaque(), old_layout, new_layout.size(),
|
||||||
) {
|
) {
|
||||||
Ok(_) => {
|
Ok(_) => {
|
||||||
self.cap = new_cap;
|
self.cap = new_cap;
|
||||||
@ -662,7 +662,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
|||||||
let new_size = elem_size * amount;
|
let new_size = elem_size * amount;
|
||||||
let align = mem::align_of::<T>();
|
let align = mem::align_of::<T>();
|
||||||
let old_layout = Layout::from_size_align_unchecked(old_size, align);
|
let old_layout = Layout::from_size_align_unchecked(old_size, align);
|
||||||
match self.a.realloc(NonNull::from(self.ptr).as_void(),
|
match self.a.realloc(NonNull::from(self.ptr).as_opaque(),
|
||||||
old_layout,
|
old_layout,
|
||||||
new_size) {
|
new_size) {
|
||||||
Ok(p) => self.ptr = p.cast().into(),
|
Ok(p) => self.ptr = p.cast().into(),
|
||||||
@ -698,7 +698,7 @@ impl<T, A: Alloc> RawVec<T, A> {
|
|||||||
let elem_size = mem::size_of::<T>();
|
let elem_size = mem::size_of::<T>();
|
||||||
if elem_size != 0 {
|
if elem_size != 0 {
|
||||||
if let Some(layout) = self.current_layout() {
|
if let Some(layout) = self.current_layout() {
|
||||||
self.a.dealloc(NonNull::from(self.ptr).as_void(), layout);
|
self.a.dealloc(NonNull::from(self.ptr).as_opaque(), layout);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -734,7 +734,7 @@ fn alloc_guard(alloc_size: usize) -> Result<(), CollectionAllocErr> {
|
|||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
use alloc::Void;
|
use alloc::Opaque;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn allocator_param() {
|
fn allocator_param() {
|
||||||
@ -754,7 +754,7 @@ mod tests {
|
|||||||
// before allocation attempts start failing.
|
// before allocation attempts start failing.
|
||||||
struct BoundedAlloc { fuel: usize }
|
struct BoundedAlloc { fuel: usize }
|
||||||
unsafe impl Alloc for BoundedAlloc {
|
unsafe impl Alloc for BoundedAlloc {
|
||||||
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr> {
|
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
let size = layout.size();
|
let size = layout.size();
|
||||||
if size > self.fuel {
|
if size > self.fuel {
|
||||||
return Err(AllocErr);
|
return Err(AllocErr);
|
||||||
@ -764,7 +764,7 @@ mod tests {
|
|||||||
err @ Err(_) => err,
|
err @ Err(_) => err,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
unsafe fn dealloc(&mut self, ptr: NonNull<Void>, layout: Layout) {
|
unsafe fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout) {
|
||||||
Global.dealloc(ptr, layout)
|
Global.dealloc(ptr, layout)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -259,7 +259,7 @@ use core::ops::CoerceUnsized;
|
|||||||
use core::ptr::{self, NonNull};
|
use core::ptr::{self, NonNull};
|
||||||
use core::convert::From;
|
use core::convert::From;
|
||||||
|
|
||||||
use alloc::{Global, Alloc, Layout, Void, box_free};
|
use alloc::{Global, Alloc, Layout, Opaque, box_free};
|
||||||
use string::String;
|
use string::String;
|
||||||
use vec::Vec;
|
use vec::Vec;
|
||||||
|
|
||||||
@ -737,7 +737,7 @@ impl<T: Clone> RcFromSlice<T> for Rc<[T]> {
|
|||||||
// In the event of a panic, elements that have been written
|
// In the event of a panic, elements that have been written
|
||||||
// into the new RcBox will be dropped, then the memory freed.
|
// into the new RcBox will be dropped, then the memory freed.
|
||||||
struct Guard<T> {
|
struct Guard<T> {
|
||||||
mem: NonNull<Void>,
|
mem: NonNull<Opaque>,
|
||||||
elems: *mut T,
|
elems: *mut T,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
n_elems: usize,
|
n_elems: usize,
|
||||||
@ -760,7 +760,7 @@ impl<T: Clone> RcFromSlice<T> for Rc<[T]> {
|
|||||||
let v_ptr = v as *const [T];
|
let v_ptr = v as *const [T];
|
||||||
let ptr = Self::allocate_for_ptr(v_ptr);
|
let ptr = Self::allocate_for_ptr(v_ptr);
|
||||||
|
|
||||||
let mem = ptr as *mut _ as *mut Void;
|
let mem = ptr as *mut _ as *mut Opaque;
|
||||||
let layout = Layout::for_value(&*ptr);
|
let layout = Layout::for_value(&*ptr);
|
||||||
|
|
||||||
// Pointer to first element
|
// Pointer to first element
|
||||||
@ -844,7 +844,7 @@ unsafe impl<#[may_dangle] T: ?Sized> Drop for Rc<T> {
|
|||||||
self.dec_weak();
|
self.dec_weak();
|
||||||
|
|
||||||
if self.weak() == 0 {
|
if self.weak() == 0 {
|
||||||
Global.dealloc(self.ptr.as_void(), Layout::for_value(self.ptr.as_ref()));
|
Global.dealloc(self.ptr.as_opaque(), Layout::for_value(self.ptr.as_ref()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -1268,7 +1268,7 @@ impl<T: ?Sized> Drop for Weak<T> {
|
|||||||
// the weak count starts at 1, and will only go to zero if all
|
// the weak count starts at 1, and will only go to zero if all
|
||||||
// the strong pointers have disappeared.
|
// the strong pointers have disappeared.
|
||||||
if self.weak() == 0 {
|
if self.weak() == 0 {
|
||||||
Global.dealloc(self.ptr.as_void(), Layout::for_value(self.ptr.as_ref()));
|
Global.dealloc(self.ptr.as_opaque(), Layout::for_value(self.ptr.as_ref()));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -41,7 +41,7 @@ const MIN_ALIGN: usize = 8;
|
|||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
const MIN_ALIGN: usize = 16;
|
const MIN_ALIGN: usize = 16;
|
||||||
|
|
||||||
use core::alloc::{Alloc, GlobalAlloc, AllocErr, Layout, Void};
|
use core::alloc::{Alloc, GlobalAlloc, AllocErr, Layout, Opaque};
|
||||||
use core::ptr::NonNull;
|
use core::ptr::NonNull;
|
||||||
|
|
||||||
#[unstable(feature = "allocator_api", issue = "32838")]
|
#[unstable(feature = "allocator_api", issue = "32838")]
|
||||||
@ -50,25 +50,25 @@ pub struct System;
|
|||||||
#[unstable(feature = "allocator_api", issue = "32838")]
|
#[unstable(feature = "allocator_api", issue = "32838")]
|
||||||
unsafe impl Alloc for System {
|
unsafe impl Alloc for System {
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr> {
|
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
NonNull::new(GlobalAlloc::alloc(self, layout)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::alloc(self, layout)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr> {
|
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
NonNull::new(GlobalAlloc::alloc_zeroed(self, layout)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::alloc_zeroed(self, layout)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn dealloc(&mut self, ptr: NonNull<Void>, layout: Layout) {
|
unsafe fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout) {
|
||||||
GlobalAlloc::dealloc(self, ptr.as_ptr(), layout)
|
GlobalAlloc::dealloc(self, ptr.as_ptr(), layout)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn realloc(&mut self,
|
unsafe fn realloc(&mut self,
|
||||||
ptr: NonNull<Void>,
|
ptr: NonNull<Opaque>,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_size: usize) -> Result<NonNull<Void>, AllocErr> {
|
new_size: usize) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
NonNull::new(GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -82,25 +82,25 @@ unsafe impl Alloc for System {
|
|||||||
#[unstable(feature = "allocator_api", issue = "32838")]
|
#[unstable(feature = "allocator_api", issue = "32838")]
|
||||||
unsafe impl<'a> Alloc for &'a System {
|
unsafe impl<'a> Alloc for &'a System {
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr> {
|
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
NonNull::new(GlobalAlloc::alloc(*self, layout)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::alloc(*self, layout)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr> {
|
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
NonNull::new(GlobalAlloc::alloc_zeroed(*self, layout)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::alloc_zeroed(*self, layout)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn dealloc(&mut self, ptr: NonNull<Void>, layout: Layout) {
|
unsafe fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout) {
|
||||||
GlobalAlloc::dealloc(*self, ptr.as_ptr(), layout)
|
GlobalAlloc::dealloc(*self, ptr.as_ptr(), layout)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn realloc(&mut self,
|
unsafe fn realloc(&mut self,
|
||||||
ptr: NonNull<Void>,
|
ptr: NonNull<Opaque>,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_size: usize) -> Result<NonNull<Void>, AllocErr> {
|
new_size: usize) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
NonNull::new(GlobalAlloc::realloc(*self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)
|
NonNull::new(GlobalAlloc::realloc(*self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -112,13 +112,13 @@ unsafe impl<'a> Alloc for &'a System {
|
|||||||
|
|
||||||
#[cfg(any(windows, unix, target_os = "cloudabi", target_os = "redox"))]
|
#[cfg(any(windows, unix, target_os = "cloudabi", target_os = "redox"))]
|
||||||
mod realloc_fallback {
|
mod realloc_fallback {
|
||||||
use core::alloc::{GlobalAlloc, Void, Layout};
|
use core::alloc::{GlobalAlloc, Opaque, Layout};
|
||||||
use core::cmp;
|
use core::cmp;
|
||||||
use core::ptr;
|
use core::ptr;
|
||||||
|
|
||||||
impl super::System {
|
impl super::System {
|
||||||
pub(crate) unsafe fn realloc_fallback(&self, ptr: *mut Void, old_layout: Layout,
|
pub(crate) unsafe fn realloc_fallback(&self, ptr: *mut Opaque, old_layout: Layout,
|
||||||
new_size: usize) -> *mut Void {
|
new_size: usize) -> *mut Opaque {
|
||||||
// Docs for GlobalAlloc::realloc require this to be valid:
|
// Docs for GlobalAlloc::realloc require this to be valid:
|
||||||
let new_layout = Layout::from_size_align_unchecked(new_size, old_layout.align());
|
let new_layout = Layout::from_size_align_unchecked(new_size, old_layout.align());
|
||||||
|
|
||||||
@ -141,20 +141,21 @@ mod platform {
|
|||||||
|
|
||||||
use MIN_ALIGN;
|
use MIN_ALIGN;
|
||||||
use System;
|
use System;
|
||||||
use core::alloc::{GlobalAlloc, Layout, Void};
|
use core::alloc::{GlobalAlloc, Layout, Opaque};
|
||||||
|
|
||||||
#[unstable(feature = "allocator_api", issue = "32838")]
|
#[unstable(feature = "allocator_api", issue = "32838")]
|
||||||
unsafe impl GlobalAlloc for System {
|
unsafe impl GlobalAlloc for System {
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
|
||||||
if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
|
if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
|
||||||
libc::malloc(layout.size()) as *mut Void
|
libc::malloc(layout.size()) as *mut Opaque
|
||||||
} else {
|
} else {
|
||||||
#[cfg(target_os = "macos")]
|
#[cfg(target_os = "macos")]
|
||||||
{
|
{
|
||||||
if layout.align() > (1 << 31) {
|
if layout.align() > (1 << 31) {
|
||||||
// FIXME: use Void::null_mut https://github.com/rust-lang/rust/issues/49659
|
// FIXME: use Opaque::null_mut
|
||||||
return 0 as *mut Void
|
// https://github.com/rust-lang/rust/issues/49659
|
||||||
|
return 0 as *mut Opaque
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
aligned_malloc(&layout)
|
aligned_malloc(&layout)
|
||||||
@ -162,9 +163,9 @@ mod platform {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Opaque {
|
||||||
if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
|
if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {
|
||||||
libc::calloc(layout.size(), 1) as *mut Void
|
libc::calloc(layout.size(), 1) as *mut Opaque
|
||||||
} else {
|
} else {
|
||||||
let ptr = self.alloc(layout.clone());
|
let ptr = self.alloc(layout.clone());
|
||||||
if !ptr.is_null() {
|
if !ptr.is_null() {
|
||||||
@ -175,24 +176,23 @@ mod platform {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn dealloc(&self, ptr: *mut Void, _layout: Layout) {
|
unsafe fn dealloc(&self, ptr: *mut Opaque, _layout: Layout) {
|
||||||
libc::free(ptr as *mut libc::c_void)
|
libc::free(ptr as *mut libc::c_void)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn realloc(&self, ptr: *mut Void, old_layout: Layout, new_size: usize) -> *mut Void {
|
unsafe fn realloc(&self, ptr: *mut Opaque, layout: Layout, new_size: usize) -> *mut Opaque {
|
||||||
let align = old_layout.align();
|
if layout.align() <= MIN_ALIGN && layout.align() <= new_size {
|
||||||
if align <= MIN_ALIGN && align <= new_size {
|
libc::realloc(ptr as *mut libc::c_void, new_size) as *mut Opaque
|
||||||
libc::realloc(ptr as *mut libc::c_void, new_size) as *mut Void
|
|
||||||
} else {
|
} else {
|
||||||
self.realloc_fallback(ptr, old_layout, new_size)
|
self.realloc_fallback(ptr, layout, new_size)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(any(target_os = "android", target_os = "redox", target_os = "solaris"))]
|
#[cfg(any(target_os = "android", target_os = "redox", target_os = "solaris"))]
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn aligned_malloc(layout: &Layout) -> *mut Void {
|
unsafe fn aligned_malloc(layout: &Layout) -> *mut Opaque {
|
||||||
// On android we currently target API level 9 which unfortunately
|
// On android we currently target API level 9 which unfortunately
|
||||||
// doesn't have the `posix_memalign` API used below. Instead we use
|
// doesn't have the `posix_memalign` API used below. Instead we use
|
||||||
// `memalign`, but this unfortunately has the property on some systems
|
// `memalign`, but this unfortunately has the property on some systems
|
||||||
@ -210,19 +210,19 @@ mod platform {
|
|||||||
// [3]: https://bugs.chromium.org/p/chromium/issues/detail?id=138579
|
// [3]: https://bugs.chromium.org/p/chromium/issues/detail?id=138579
|
||||||
// [4]: https://chromium.googlesource.com/chromium/src/base/+/master/
|
// [4]: https://chromium.googlesource.com/chromium/src/base/+/master/
|
||||||
// /memory/aligned_memory.cc
|
// /memory/aligned_memory.cc
|
||||||
libc::memalign(layout.align(), layout.size()) as *mut Void
|
libc::memalign(layout.align(), layout.size()) as *mut Opaque
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(not(any(target_os = "android", target_os = "redox", target_os = "solaris")))]
|
#[cfg(not(any(target_os = "android", target_os = "redox", target_os = "solaris")))]
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn aligned_malloc(layout: &Layout) -> *mut Void {
|
unsafe fn aligned_malloc(layout: &Layout) -> *mut Opaque {
|
||||||
let mut out = ptr::null_mut();
|
let mut out = ptr::null_mut();
|
||||||
let ret = libc::posix_memalign(&mut out, layout.align(), layout.size());
|
let ret = libc::posix_memalign(&mut out, layout.align(), layout.size());
|
||||||
if ret != 0 {
|
if ret != 0 {
|
||||||
// FIXME: use Void::null_mut https://github.com/rust-lang/rust/issues/49659
|
// FIXME: use Opaque::null_mut https://github.com/rust-lang/rust/issues/49659
|
||||||
0 as *mut Void
|
0 as *mut Opaque
|
||||||
} else {
|
} else {
|
||||||
out as *mut Void
|
out as *mut Opaque
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -232,7 +232,7 @@ mod platform {
|
|||||||
mod platform {
|
mod platform {
|
||||||
use MIN_ALIGN;
|
use MIN_ALIGN;
|
||||||
use System;
|
use System;
|
||||||
use core::alloc::{GlobalAlloc, Void, Layout};
|
use core::alloc::{GlobalAlloc, Opaque, Layout};
|
||||||
|
|
||||||
type LPVOID = *mut u8;
|
type LPVOID = *mut u8;
|
||||||
type HANDLE = LPVOID;
|
type HANDLE = LPVOID;
|
||||||
@ -264,7 +264,7 @@ mod platform {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn allocate_with_flags(layout: Layout, flags: DWORD) -> *mut Void {
|
unsafe fn allocate_with_flags(layout: Layout, flags: DWORD) -> *mut Opaque {
|
||||||
let ptr = if layout.align() <= MIN_ALIGN {
|
let ptr = if layout.align() <= MIN_ALIGN {
|
||||||
HeapAlloc(GetProcessHeap(), flags, layout.size())
|
HeapAlloc(GetProcessHeap(), flags, layout.size())
|
||||||
} else {
|
} else {
|
||||||
@ -276,23 +276,23 @@ mod platform {
|
|||||||
align_ptr(ptr, layout.align())
|
align_ptr(ptr, layout.align())
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
ptr as *mut Void
|
ptr as *mut Opaque
|
||||||
}
|
}
|
||||||
|
|
||||||
#[unstable(feature = "allocator_api", issue = "32838")]
|
#[unstable(feature = "allocator_api", issue = "32838")]
|
||||||
unsafe impl GlobalAlloc for System {
|
unsafe impl GlobalAlloc for System {
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
|
||||||
allocate_with_flags(layout, 0)
|
allocate_with_flags(layout, 0)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Opaque {
|
||||||
allocate_with_flags(layout, HEAP_ZERO_MEMORY)
|
allocate_with_flags(layout, HEAP_ZERO_MEMORY)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn dealloc(&self, ptr: *mut Void, layout: Layout) {
|
unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) {
|
||||||
if layout.align() <= MIN_ALIGN {
|
if layout.align() <= MIN_ALIGN {
|
||||||
let err = HeapFree(GetProcessHeap(), 0, ptr as LPVOID);
|
let err = HeapFree(GetProcessHeap(), 0, ptr as LPVOID);
|
||||||
debug_assert!(err != 0, "Failed to free heap memory: {}",
|
debug_assert!(err != 0, "Failed to free heap memory: {}",
|
||||||
@ -306,12 +306,11 @@ mod platform {
|
|||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn realloc(&self, ptr: *mut Void, old_layout: Layout, new_size: usize) -> *mut Void {
|
unsafe fn realloc(&self, ptr: *mut Opaque, layout: Layout, new_size: usize) -> *mut Opaque {
|
||||||
let align = old_layout.align();
|
if layout.align() <= MIN_ALIGN {
|
||||||
if align <= MIN_ALIGN {
|
HeapReAlloc(GetProcessHeap(), 0, ptr as LPVOID, new_size) as *mut Opaque
|
||||||
HeapReAlloc(GetProcessHeap(), 0, ptr as LPVOID, new_size) as *mut Void
|
|
||||||
} else {
|
} else {
|
||||||
self.realloc_fallback(ptr, old_layout, new_size)
|
self.realloc_fallback(ptr, layout, new_size)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
@ -338,7 +337,7 @@ mod platform {
|
|||||||
mod platform {
|
mod platform {
|
||||||
extern crate dlmalloc;
|
extern crate dlmalloc;
|
||||||
|
|
||||||
use core::alloc::{GlobalAlloc, Layout, Void};
|
use core::alloc::{GlobalAlloc, Layout, Opaque};
|
||||||
use System;
|
use System;
|
||||||
|
|
||||||
// No need for synchronization here as wasm is currently single-threaded
|
// No need for synchronization here as wasm is currently single-threaded
|
||||||
@ -347,23 +346,23 @@ mod platform {
|
|||||||
#[unstable(feature = "allocator_api", issue = "32838")]
|
#[unstable(feature = "allocator_api", issue = "32838")]
|
||||||
unsafe impl GlobalAlloc for System {
|
unsafe impl GlobalAlloc for System {
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
|
||||||
DLMALLOC.malloc(layout.size(), layout.align()) as *mut Void
|
DLMALLOC.malloc(layout.size(), layout.align()) as *mut Opaque
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Opaque {
|
||||||
DLMALLOC.calloc(layout.size(), layout.align()) as *mut Void
|
DLMALLOC.calloc(layout.size(), layout.align()) as *mut Opaque
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn dealloc(&self, ptr: *mut Void, layout: Layout) {
|
unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) {
|
||||||
DLMALLOC.free(ptr as *mut u8, layout.size(), layout.align())
|
DLMALLOC.free(ptr as *mut u8, layout.size(), layout.align())
|
||||||
}
|
}
|
||||||
|
|
||||||
#[inline]
|
#[inline]
|
||||||
unsafe fn realloc(&self, ptr: *mut Void, layout: Layout, new_size: usize) -> *mut Void {
|
unsafe fn realloc(&self, ptr: *mut Opaque, layout: Layout, new_size: usize) -> *mut Opaque {
|
||||||
DLMALLOC.realloc(ptr as *mut u8, layout.size(), layout.align(), new_size) as *mut Void
|
DLMALLOC.realloc(ptr as *mut u8, layout.size(), layout.align(), new_size) as *mut Opaque
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -24,12 +24,12 @@ use ptr::{self, NonNull};
|
|||||||
extern {
|
extern {
|
||||||
/// An opaque, unsized type. Used for pointers to allocated memory.
|
/// An opaque, unsized type. Used for pointers to allocated memory.
|
||||||
///
|
///
|
||||||
/// This type can only be used behind a pointer like `*mut Void` or `ptr::NonNull<Void>`.
|
/// This type can only be used behind a pointer like `*mut Opaque` or `ptr::NonNull<Opaque>`.
|
||||||
/// Such pointers are similar to C’s `void*` type.
|
/// Such pointers are similar to C’s `void*` type.
|
||||||
pub type Void;
|
pub type Opaque;
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Void {
|
impl Opaque {
|
||||||
/// Similar to `std::ptr::null`, which requires `T: Sized`.
|
/// Similar to `std::ptr::null`, which requires `T: Sized`.
|
||||||
pub fn null() -> *const Self {
|
pub fn null() -> *const Self {
|
||||||
0 as _
|
0 as _
|
||||||
@ -44,7 +44,7 @@ impl Void {
|
|||||||
/// Represents the combination of a starting address and
|
/// Represents the combination of a starting address and
|
||||||
/// a total capacity of the returned block.
|
/// a total capacity of the returned block.
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct Excess(pub NonNull<Void>, pub usize);
|
pub struct Excess(pub NonNull<Opaque>, pub usize);
|
||||||
|
|
||||||
fn size_align<T>() -> (usize, usize) {
|
fn size_align<T>() -> (usize, usize) {
|
||||||
(mem::size_of::<T>(), mem::align_of::<T>())
|
(mem::size_of::<T>(), mem::align_of::<T>())
|
||||||
@ -387,11 +387,11 @@ impl From<AllocErr> for CollectionAllocErr {
|
|||||||
|
|
||||||
// FIXME: docs
|
// FIXME: docs
|
||||||
pub unsafe trait GlobalAlloc {
|
pub unsafe trait GlobalAlloc {
|
||||||
unsafe fn alloc(&self, layout: Layout) -> *mut Void;
|
unsafe fn alloc(&self, layout: Layout) -> *mut Opaque;
|
||||||
|
|
||||||
unsafe fn dealloc(&self, ptr: *mut Void, layout: Layout);
|
unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout);
|
||||||
|
|
||||||
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut Opaque {
|
||||||
let size = layout.size();
|
let size = layout.size();
|
||||||
let ptr = self.alloc(layout);
|
let ptr = self.alloc(layout);
|
||||||
if !ptr.is_null() {
|
if !ptr.is_null() {
|
||||||
@ -404,7 +404,7 @@ pub unsafe trait GlobalAlloc {
|
|||||||
///
|
///
|
||||||
/// `new_size`, when rounded up to the nearest multiple of `old_layout.align()`,
|
/// `new_size`, when rounded up to the nearest multiple of `old_layout.align()`,
|
||||||
/// must not overflow (i.e. the rounded value must be less than `usize::MAX`).
|
/// must not overflow (i.e. the rounded value must be less than `usize::MAX`).
|
||||||
unsafe fn realloc(&self, ptr: *mut Void, old_layout: Layout, new_size: usize) -> *mut Void {
|
unsafe fn realloc(&self, ptr: *mut Opaque, old_layout: Layout, new_size: usize) -> *mut Opaque {
|
||||||
let new_layout = Layout::from_size_align_unchecked(new_size, old_layout.align());
|
let new_layout = Layout::from_size_align_unchecked(new_size, old_layout.align());
|
||||||
let new_ptr = self.alloc(new_layout);
|
let new_ptr = self.alloc(new_layout);
|
||||||
if !new_ptr.is_null() {
|
if !new_ptr.is_null() {
|
||||||
@ -554,7 +554,7 @@ pub unsafe trait Alloc {
|
|||||||
/// Clients wishing to abort computation in response to an
|
/// Clients wishing to abort computation in response to an
|
||||||
/// allocation error are encouraged to call the allocator's `oom`
|
/// allocation error are encouraged to call the allocator's `oom`
|
||||||
/// method, rather than directly invoking `panic!` or similar.
|
/// method, rather than directly invoking `panic!` or similar.
|
||||||
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr>;
|
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr>;
|
||||||
|
|
||||||
/// Deallocate the memory referenced by `ptr`.
|
/// Deallocate the memory referenced by `ptr`.
|
||||||
///
|
///
|
||||||
@ -571,7 +571,7 @@ pub unsafe trait Alloc {
|
|||||||
/// * In addition to fitting the block of memory `layout`, the
|
/// * In addition to fitting the block of memory `layout`, the
|
||||||
/// alignment of the `layout` must match the alignment used
|
/// alignment of the `layout` must match the alignment used
|
||||||
/// to allocate that block of memory.
|
/// to allocate that block of memory.
|
||||||
unsafe fn dealloc(&mut self, ptr: NonNull<Void>, layout: Layout);
|
unsafe fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout);
|
||||||
|
|
||||||
/// Allocator-specific method for signaling an out-of-memory
|
/// Allocator-specific method for signaling an out-of-memory
|
||||||
/// condition.
|
/// condition.
|
||||||
@ -689,9 +689,9 @@ pub unsafe trait Alloc {
|
|||||||
/// reallocation error are encouraged to call the allocator's `oom`
|
/// reallocation error are encouraged to call the allocator's `oom`
|
||||||
/// method, rather than directly invoking `panic!` or similar.
|
/// method, rather than directly invoking `panic!` or similar.
|
||||||
unsafe fn realloc(&mut self,
|
unsafe fn realloc(&mut self,
|
||||||
ptr: NonNull<Void>,
|
ptr: NonNull<Opaque>,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_size: usize) -> Result<NonNull<Void>, AllocErr> {
|
new_size: usize) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
let old_size = layout.size();
|
let old_size = layout.size();
|
||||||
|
|
||||||
if new_size >= old_size {
|
if new_size >= old_size {
|
||||||
@ -732,7 +732,7 @@ pub unsafe trait Alloc {
|
|||||||
/// Clients wishing to abort computation in response to an
|
/// Clients wishing to abort computation in response to an
|
||||||
/// allocation error are encouraged to call the allocator's `oom`
|
/// allocation error are encouraged to call the allocator's `oom`
|
||||||
/// method, rather than directly invoking `panic!` or similar.
|
/// method, rather than directly invoking `panic!` or similar.
|
||||||
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Void>, AllocErr> {
|
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
|
||||||
let size = layout.size();
|
let size = layout.size();
|
||||||
let p = self.alloc(layout);
|
let p = self.alloc(layout);
|
||||||
if let Ok(p) = p {
|
if let Ok(p) = p {
|
||||||
@ -781,7 +781,7 @@ pub unsafe trait Alloc {
|
|||||||
/// reallocation error are encouraged to call the allocator's `oom`
|
/// reallocation error are encouraged to call the allocator's `oom`
|
||||||
/// method, rather than directly invoking `panic!` or similar.
|
/// method, rather than directly invoking `panic!` or similar.
|
||||||
unsafe fn realloc_excess(&mut self,
|
unsafe fn realloc_excess(&mut self,
|
||||||
ptr: NonNull<Void>,
|
ptr: NonNull<Opaque>,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_size: usize) -> Result<Excess, AllocErr> {
|
new_size: usize) -> Result<Excess, AllocErr> {
|
||||||
let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
|
let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
|
||||||
@ -826,7 +826,7 @@ pub unsafe trait Alloc {
|
|||||||
/// `grow_in_place` failures without aborting, or to fall back on
|
/// `grow_in_place` failures without aborting, or to fall back on
|
||||||
/// another reallocation method before resorting to an abort.
|
/// another reallocation method before resorting to an abort.
|
||||||
unsafe fn grow_in_place(&mut self,
|
unsafe fn grow_in_place(&mut self,
|
||||||
ptr: NonNull<Void>,
|
ptr: NonNull<Opaque>,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_size: usize) -> Result<(), CannotReallocInPlace> {
|
new_size: usize) -> Result<(), CannotReallocInPlace> {
|
||||||
let _ = ptr; // this default implementation doesn't care about the actual address.
|
let _ = ptr; // this default implementation doesn't care about the actual address.
|
||||||
@ -881,7 +881,7 @@ pub unsafe trait Alloc {
|
|||||||
/// `shrink_in_place` failures without aborting, or to fall back
|
/// `shrink_in_place` failures without aborting, or to fall back
|
||||||
/// on another reallocation method before resorting to an abort.
|
/// on another reallocation method before resorting to an abort.
|
||||||
unsafe fn shrink_in_place(&mut self,
|
unsafe fn shrink_in_place(&mut self,
|
||||||
ptr: NonNull<Void>,
|
ptr: NonNull<Opaque>,
|
||||||
layout: Layout,
|
layout: Layout,
|
||||||
new_size: usize) -> Result<(), CannotReallocInPlace> {
|
new_size: usize) -> Result<(), CannotReallocInPlace> {
|
||||||
let _ = ptr; // this default implementation doesn't care about the actual address.
|
let _ = ptr; // this default implementation doesn't care about the actual address.
|
||||||
@ -960,7 +960,7 @@ pub unsafe trait Alloc {
|
|||||||
{
|
{
|
||||||
let k = Layout::new::<T>();
|
let k = Layout::new::<T>();
|
||||||
if k.size() > 0 {
|
if k.size() > 0 {
|
||||||
self.dealloc(ptr.as_void(), k);
|
self.dealloc(ptr.as_opaque(), k);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -1048,7 +1048,7 @@ pub unsafe trait Alloc {
|
|||||||
match (Layout::array::<T>(n_old), Layout::array::<T>(n_new)) {
|
match (Layout::array::<T>(n_old), Layout::array::<T>(n_new)) {
|
||||||
(Ok(ref k_old), Ok(ref k_new)) if k_old.size() > 0 && k_new.size() > 0 => {
|
(Ok(ref k_old), Ok(ref k_new)) if k_old.size() > 0 && k_new.size() > 0 => {
|
||||||
debug_assert!(k_old.align() == k_new.align());
|
debug_assert!(k_old.align() == k_new.align());
|
||||||
self.realloc(ptr.as_void(), k_old.clone(), k_new.size()).map(NonNull::cast)
|
self.realloc(ptr.as_opaque(), k_old.clone(), k_new.size()).map(NonNull::cast)
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
Err(AllocErr)
|
Err(AllocErr)
|
||||||
@ -1081,7 +1081,7 @@ pub unsafe trait Alloc {
|
|||||||
{
|
{
|
||||||
match Layout::array::<T>(n) {
|
match Layout::array::<T>(n) {
|
||||||
Ok(ref k) if k.size() > 0 => {
|
Ok(ref k) if k.size() > 0 => {
|
||||||
Ok(self.dealloc(ptr.as_void(), k.clone()))
|
Ok(self.dealloc(ptr.as_opaque(), k.clone()))
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
Err(AllocErr)
|
Err(AllocErr)
|
||||||
|
@ -2751,9 +2751,9 @@ impl<T: ?Sized> NonNull<T> {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Cast to a `Void` pointer
|
/// Cast to an `Opaque` pointer
|
||||||
#[unstable(feature = "allocator_api", issue = "32838")]
|
#[unstable(feature = "allocator_api", issue = "32838")]
|
||||||
pub fn as_void(self) -> NonNull<::alloc::Void> {
|
pub fn as_opaque(self) -> NonNull<::alloc::Opaque> {
|
||||||
unsafe {
|
unsafe {
|
||||||
NonNull::new_unchecked(self.as_ptr() as _)
|
NonNull::new_unchecked(self.as_ptr() as _)
|
||||||
}
|
}
|
||||||
|
@ -221,7 +221,7 @@ impl<'a> AllocFnFactory<'a> {
|
|||||||
let ident = ident();
|
let ident = ident();
|
||||||
args.push(self.cx.arg(self.span, ident, self.ptr_u8()));
|
args.push(self.cx.arg(self.span, ident, self.ptr_u8()));
|
||||||
let arg = self.cx.expr_ident(self.span, ident);
|
let arg = self.cx.expr_ident(self.span, ident);
|
||||||
self.cx.expr_cast(self.span, arg, self.ptr_void())
|
self.cx.expr_cast(self.span, arg, self.ptr_opaque())
|
||||||
}
|
}
|
||||||
|
|
||||||
AllocatorTy::Usize => {
|
AllocatorTy::Usize => {
|
||||||
@ -276,13 +276,13 @@ impl<'a> AllocFnFactory<'a> {
|
|||||||
self.cx.ty_ptr(self.span, ty_u8, Mutability::Mutable)
|
self.cx.ty_ptr(self.span, ty_u8, Mutability::Mutable)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn ptr_void(&self) -> P<Ty> {
|
fn ptr_opaque(&self) -> P<Ty> {
|
||||||
let void = self.cx.path(self.span, vec![
|
let opaque = self.cx.path(self.span, vec![
|
||||||
self.core,
|
self.core,
|
||||||
Ident::from_str("alloc"),
|
Ident::from_str("alloc"),
|
||||||
Ident::from_str("Void"),
|
Ident::from_str("Opaque"),
|
||||||
]);
|
]);
|
||||||
let ty_void = self.cx.ty_path(void);
|
let ty_opaque = self.cx.ty_path(opaque);
|
||||||
self.cx.ty_ptr(self.span, ty_void, Mutability::Mutable)
|
self.cx.ty_ptr(self.span, ty_opaque, Mutability::Mutable)
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -21,7 +21,7 @@
|
|||||||
#[doc(hidden)]
|
#[doc(hidden)]
|
||||||
#[allow(unused_attributes)]
|
#[allow(unused_attributes)]
|
||||||
pub mod __default_lib_allocator {
|
pub mod __default_lib_allocator {
|
||||||
use super::{System, Layout, GlobalAlloc, Void};
|
use super::{System, Layout, GlobalAlloc, Opaque};
|
||||||
// for symbol names src/librustc/middle/allocator.rs
|
// for symbol names src/librustc/middle/allocator.rs
|
||||||
// for signatures src/librustc_allocator/lib.rs
|
// for signatures src/librustc_allocator/lib.rs
|
||||||
|
|
||||||
@ -46,7 +46,7 @@ pub mod __default_lib_allocator {
|
|||||||
pub unsafe extern fn __rdl_dealloc(ptr: *mut u8,
|
pub unsafe extern fn __rdl_dealloc(ptr: *mut u8,
|
||||||
size: usize,
|
size: usize,
|
||||||
align: usize) {
|
align: usize) {
|
||||||
System.dealloc(ptr as *mut Void, Layout::from_size_align_unchecked(size, align))
|
System.dealloc(ptr as *mut Opaque, Layout::from_size_align_unchecked(size, align))
|
||||||
}
|
}
|
||||||
|
|
||||||
#[no_mangle]
|
#[no_mangle]
|
||||||
@ -56,7 +56,7 @@ pub mod __default_lib_allocator {
|
|||||||
align: usize,
|
align: usize,
|
||||||
new_size: usize) -> *mut u8 {
|
new_size: usize) -> *mut u8 {
|
||||||
let old_layout = Layout::from_size_align_unchecked(old_size, align);
|
let old_layout = Layout::from_size_align_unchecked(old_size, align);
|
||||||
System.realloc(ptr as *mut Void, old_layout, new_size) as *mut u8
|
System.realloc(ptr as *mut Opaque, old_layout, new_size) as *mut u8
|
||||||
}
|
}
|
||||||
|
|
||||||
#[no_mangle]
|
#[no_mangle]
|
||||||
|
@ -1183,7 +1183,7 @@ unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for RawTable<K, V> {
|
|||||||
debug_assert!(!oflo, "should be impossible");
|
debug_assert!(!oflo, "should be impossible");
|
||||||
|
|
||||||
unsafe {
|
unsafe {
|
||||||
Global.dealloc(NonNull::new_unchecked(self.hashes.ptr()).as_void(),
|
Global.dealloc(NonNull::new_unchecked(self.hashes.ptr()).as_opaque(),
|
||||||
Layout::from_size_align(size, align).unwrap());
|
Layout::from_size_align(size, align).unwrap());
|
||||||
// Remember how everything was allocated out of one buffer
|
// Remember how everything was allocated out of one buffer
|
||||||
// during initialization? We only need one call to free here.
|
// during initialization? We only need one call to free here.
|
||||||
|
@ -16,11 +16,11 @@ use std::alloc::*;
|
|||||||
pub struct A;
|
pub struct A;
|
||||||
|
|
||||||
unsafe impl GlobalAlloc for A {
|
unsafe impl GlobalAlloc for A {
|
||||||
unsafe fn alloc(&self, _: Layout) -> *mut Void {
|
unsafe fn alloc(&self, _: Layout) -> *mut Opaque {
|
||||||
loop {}
|
loop {}
|
||||||
}
|
}
|
||||||
|
|
||||||
unsafe fn dealloc(&self, _ptr: *mut Void, _: Layout) {
|
unsafe fn dealloc(&self, _ptr: *mut Opaque, _: Layout) {
|
||||||
loop {}
|
loop {}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
@ -13,18 +13,18 @@
|
|||||||
#![feature(heap_api, allocator_api)]
|
#![feature(heap_api, allocator_api)]
|
||||||
#![crate_type = "rlib"]
|
#![crate_type = "rlib"]
|
||||||
|
|
||||||
use std::heap::{GlobalAlloc, System, Layout, Void};
|
use std::heap::{GlobalAlloc, System, Layout, Opaque};
|
||||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||||
|
|
||||||
pub struct A(pub AtomicUsize);
|
pub struct A(pub AtomicUsize);
|
||||||
|
|
||||||
unsafe impl GlobalAlloc for A {
|
unsafe impl GlobalAlloc for A {
|
||||||
unsafe fn alloc(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
|
||||||
self.0.fetch_add(1, Ordering::SeqCst);
|
self.0.fetch_add(1, Ordering::SeqCst);
|
||||||
System.alloc(layout)
|
System.alloc(layout)
|
||||||
}
|
}
|
||||||
|
|
||||||
unsafe fn dealloc(&self, ptr: *mut Void, layout: Layout) {
|
unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) {
|
||||||
self.0.fetch_add(1, Ordering::SeqCst);
|
self.0.fetch_add(1, Ordering::SeqCst);
|
||||||
System.dealloc(ptr, layout)
|
System.dealloc(ptr, layout)
|
||||||
}
|
}
|
||||||
|
@ -15,7 +15,7 @@
|
|||||||
|
|
||||||
extern crate helper;
|
extern crate helper;
|
||||||
|
|
||||||
use std::alloc::{self, Global, Alloc, System, Layout, Void};
|
use std::alloc::{self, Global, Alloc, System, Layout, Opaque};
|
||||||
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
|
use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
|
||||||
|
|
||||||
static HITS: AtomicUsize = ATOMIC_USIZE_INIT;
|
static HITS: AtomicUsize = ATOMIC_USIZE_INIT;
|
||||||
@ -23,12 +23,12 @@ static HITS: AtomicUsize = ATOMIC_USIZE_INIT;
|
|||||||
struct A;
|
struct A;
|
||||||
|
|
||||||
unsafe impl alloc::GlobalAlloc for A {
|
unsafe impl alloc::GlobalAlloc for A {
|
||||||
unsafe fn alloc(&self, layout: Layout) -> *mut Void {
|
unsafe fn alloc(&self, layout: Layout) -> *mut Opaque {
|
||||||
HITS.fetch_add(1, Ordering::SeqCst);
|
HITS.fetch_add(1, Ordering::SeqCst);
|
||||||
System.alloc(layout)
|
System.alloc(layout)
|
||||||
}
|
}
|
||||||
|
|
||||||
unsafe fn dealloc(&self, ptr: *mut Void, layout: Layout) {
|
unsafe fn dealloc(&self, ptr: *mut Opaque, layout: Layout) {
|
||||||
HITS.fetch_add(1, Ordering::SeqCst);
|
HITS.fetch_add(1, Ordering::SeqCst);
|
||||||
System.dealloc(ptr, layout)
|
System.dealloc(ptr, layout)
|
||||||
}
|
}
|
||||||
|
@ -64,7 +64,7 @@ unsafe fn test_triangle() -> bool {
|
|||||||
println!("deallocate({:?}, {:?}", ptr, layout);
|
println!("deallocate({:?}, {:?}", ptr, layout);
|
||||||
}
|
}
|
||||||
|
|
||||||
Global.dealloc(NonNull::new_unchecked(ptr).as_void(), layout);
|
Global.dealloc(NonNull::new_unchecked(ptr).as_opaque(), layout);
|
||||||
}
|
}
|
||||||
|
|
||||||
unsafe fn reallocate(ptr: *mut u8, old: Layout, new: Layout) -> *mut u8 {
|
unsafe fn reallocate(ptr: *mut u8, old: Layout, new: Layout) -> *mut u8 {
|
||||||
@ -72,7 +72,7 @@ unsafe fn test_triangle() -> bool {
|
|||||||
println!("reallocate({:?}, old={:?}, new={:?})", ptr, old, new);
|
println!("reallocate({:?}, old={:?}, new={:?})", ptr, old, new);
|
||||||
}
|
}
|
||||||
|
|
||||||
let ret = Global.realloc(NonNull::new_unchecked(ptr).as_void(), old.clone(), new.size())
|
let ret = Global.realloc(NonNull::new_unchecked(ptr).as_opaque(), old.clone(), new.size())
|
||||||
.unwrap_or_else(|_| Global.oom());
|
.unwrap_or_else(|_| Global.oom());
|
||||||
|
|
||||||
if PRINT {
|
if PRINT {
|
||||||
|
Loading…
Reference in New Issue
Block a user