if !ptr.is_null() {
ptr
} else {
- oom(layout)
+ handle_alloc_error(layout)
}
}
}
///
/// The default behavior of this function is to print a message to standard error
/// and abort the process.
-/// It can be replaced with [`set_oom_hook`] and [`take_oom_hook`].
+/// It can be replaced with [`set_alloc_error_hook`] and [`take_alloc_error_hook`].
///
-/// [`set_oom_hook`]: ../../std/alloc/fn.set_oom_hook.html
-/// [`take_oom_hook`]: ../../std/alloc/fn.take_oom_hook.html
+/// [`set_alloc_error_hook`]: ../../std/alloc/fn.set_alloc_error_hook.html
+/// [`take_alloc_error_hook`]: ../../std/alloc/fn.take_alloc_error_hook.html
#[stable(feature = "global_alloc", since = "1.28.0")]
#[rustc_allocator_nounwind]
-pub fn oom(layout: Layout) -> ! {
+pub fn handle_alloc_error(layout: Layout) -> ! {
#[allow(improper_ctypes)]
extern "Rust" {
#[lang = "oom"]
extern crate test;
use self::test::Bencher;
use boxed::Box;
- use alloc::{Global, Alloc, Layout, oom};
+ use alloc::{Global, Alloc, Layout, handle_alloc_error};
#[test]
fn allocate_zeroed() {
unsafe {
let layout = Layout::from_size_align(1024, 1).unwrap();
let ptr = Global.alloc_zeroed(layout.clone())
- .unwrap_or_else(|_| oom(layout));
+ .unwrap_or_else(|_| handle_alloc_error(layout));
let mut i = ptr.cast::<u8>().as_ptr();
let end = i.offset(layout.size() as isize);
use core::{isize, usize};
use core::convert::From;
-use alloc::{Global, Alloc, Layout, box_free, oom};
+use alloc::{Global, Alloc, Layout, box_free, handle_alloc_error};
use boxed::Box;
use string::String;
use vec::Vec;
let layout = Layout::for_value(&*fake_ptr);
let mem = Global.alloc(layout)
- .unwrap_or_else(|_| oom(layout));
+ .unwrap_or_else(|_| handle_alloc_error(layout));
// Initialize the real ArcInner
let inner = set_data_ptr(ptr as *mut T, mem.as_ptr() as *mut u8) as *mut ArcInner<T>;
use core::ptr::{self, NonNull, Unique};
use core::slice;
-use alloc::{Alloc, Layout, Global, oom};
+use alloc::{Alloc, Layout, Global, handle_alloc_error};
use alloc::CollectionAllocErr;
use alloc::CollectionAllocErr::*;
use boxed::Box;
};
match result {
Ok(ptr) => ptr.cast(),
- Err(_) => oom(layout),
+ Err(_) => handle_alloc_error(layout),
}
};
new_size);
match ptr_res {
Ok(ptr) => (new_cap, ptr.cast().into()),
- Err(_) => oom(Layout::from_size_align_unchecked(new_size, cur.align())),
+ Err(_) => handle_alloc_error(
+ Layout::from_size_align_unchecked(new_size, cur.align())
+ ),
}
}
None => {
let new_cap = if elem_size > (!0) / 8 { 1 } else { 4 };
match self.a.alloc_array::<T>(new_cap) {
Ok(ptr) => (new_cap, ptr.into()),
- Err(_) => oom(Layout::array::<T>(new_cap).unwrap()),
+ Err(_) => handle_alloc_error(Layout::array::<T>(new_cap).unwrap()),
}
}
};
old_layout,
new_size) {
Ok(p) => self.ptr = p.cast().into(),
- Err(_) => oom(Layout::from_size_align_unchecked(new_size, align)),
+ Err(_) => handle_alloc_error(
+ Layout::from_size_align_unchecked(new_size, align)
+ ),
}
}
self.cap = amount;
};
match (&res, fallibility) {
- (Err(AllocErr), Infallible) => oom(new_layout),
+ (Err(AllocErr), Infallible) => handle_alloc_error(new_layout),
_ => {}
}
use core::ptr::{self, NonNull};
use core::convert::From;
-use alloc::{Global, Alloc, Layout, box_free, oom};
+use alloc::{Global, Alloc, Layout, box_free, handle_alloc_error};
use string::String;
use vec::Vec;
let layout = Layout::for_value(&*fake_ptr);
let mem = Global.alloc(layout)
- .unwrap_or_else(|_| oom(layout));
+ .unwrap_or_else(|_| handle_alloc_error(layout));
// Initialize the real RcBox
let inner = set_data_ptr(ptr as *mut T, mem.as_ptr() as *mut u8) as *mut RcBox<T>;
/// library that aborts on memory exhaustion.)
///
/// Clients wishing to abort computation in response to an
- /// allocation error are encouraged to call the [`oom`] function,
+ /// allocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
#[stable(feature = "global_alloc", since = "1.28.0")]
unsafe fn alloc(&self, layout: Layout) -> *mut u8;
/// just as in `alloc`.
///
/// Clients wishing to abort computation in response to an
- /// allocation error are encouraged to call the [`oom`] function,
+ /// allocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
#[stable(feature = "global_alloc", since = "1.28.0")]
unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {
let size = layout.size();
/// library that aborts on memory exhaustion.)
///
/// Clients wishing to abort computation in response to a
- /// reallocation error are encouraged to call the [`oom`] function,
+ /// reallocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
#[stable(feature = "global_alloc", since = "1.28.0")]
unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {
let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
/// library that aborts on memory exhaustion.)
///
/// Clients wishing to abort computation in response to an
- /// allocation error are encouraged to call the [`oom`] function,
+ /// allocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr>;
/// Deallocate the memory referenced by `ptr`.
/// library that aborts on memory exhaustion.)
///
/// Clients wishing to abort computation in response to a
- /// reallocation error are encouraged to call the [`oom`] function,
+ /// reallocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
unsafe fn realloc(&mut self,
ptr: NonNull<u8>,
layout: Layout,
/// constraints, just as in `alloc`.
///
/// Clients wishing to abort computation in response to an
- /// allocation error are encouraged to call the [`oom`] function,
+ /// allocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {
let size = layout.size();
let p = self.alloc(layout);
/// constraints, just as in `alloc`.
///
/// Clients wishing to abort computation in response to an
- /// allocation error are encouraged to call the [`oom`] function,
+ /// allocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, AllocErr> {
let usable_size = self.usable_size(&layout);
self.alloc(layout).map(|p| Excess(p, usable_size.1))
/// constraints, just as in `realloc`.
///
/// Clients wishing to abort computation in response to a
- /// reallocation error are encouraged to call the [`oom`] function,
+ /// reallocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
unsafe fn realloc_excess(&mut self,
ptr: NonNull<u8>,
layout: Layout,
/// unable to assert that the memory block referenced by `ptr`
/// could fit `layout`.
///
- /// Note that one cannot pass `CannotReallocInPlace` to the `oom`
+ /// Note that one cannot pass `CannotReallocInPlace` to the `handle_alloc_error`
/// function; clients are expected either to be able to recover from
/// `grow_in_place` failures without aborting, or to fall back on
/// another reallocation method before resorting to an abort.
/// unable to assert that the memory block referenced by `ptr`
/// could fit `layout`.
///
- /// Note that one cannot pass `CannotReallocInPlace` to the `oom`
+ /// Note that one cannot pass `CannotReallocInPlace` to the `handle_alloc_error`
/// function; clients are expected either to be able to recover from
/// `shrink_in_place` failures without aborting, or to fall back
/// on another reallocation method before resorting to an abort.
/// will *not* yield undefined behavior.
///
/// Clients wishing to abort computation in response to an
- /// allocation error are encouraged to call the [`oom`] function,
+ /// allocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
fn alloc_one<T>(&mut self) -> Result<NonNull<T>, AllocErr>
where Self: Sized
{
/// Always returns `Err` on arithmetic overflow.
///
/// Clients wishing to abort computation in response to an
- /// allocation error are encouraged to call the [`oom`] function,
+ /// allocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
fn alloc_array<T>(&mut self, n: usize) -> Result<NonNull<T>, AllocErr>
where Self: Sized
{
/// Always returns `Err` on arithmetic overflow.
///
/// Clients wishing to abort computation in response to a
- /// reallocation error are encouraged to call the [`oom`] function,
+ /// reallocation error are encouraged to call the [`handle_alloc_error`] function,
/// rather than directly invoking `panic!` or similar.
///
- /// [`oom`]: ../../alloc/alloc/fn.oom.html
+ /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
unsafe fn realloc_array<T>(&mut self,
ptr: NonNull<T>,
n_old: usize,
static HOOK: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());
-/// Registers a custom OOM hook, replacing any that was previously registered.
+/// Registers a custom allocation error hook, replacing any that was previously registered.
///
-/// The OOM hook is invoked when an infallible memory allocation fails, before
+/// The allocation error hook is invoked when an infallible memory allocation fails, before
/// the runtime aborts. The default hook prints a message to standard error,
-/// but this behavior can be customized with the [`set_oom_hook`] and
-/// [`take_oom_hook`] functions.
+/// but this behavior can be customized with the [`set_alloc_error_hook`] and
+/// [`take_alloc_error_hook`] functions.
///
/// The hook is provided with a `Layout` struct which contains information
/// about the allocation that failed.
///
-/// The OOM hook is a global resource.
-#[unstable(feature = "oom_hook", issue = "51245")]
-pub fn set_oom_hook(hook: fn(Layout)) {
+/// The allocation error hook is a global resource.
+#[unstable(feature = "alloc_error_hook", issue = "51245")]
+pub fn set_alloc_error_hook(hook: fn(Layout)) {
HOOK.store(hook as *mut (), Ordering::SeqCst);
}
-/// Unregisters the current OOM hook, returning it.
+/// Unregisters the current allocation error hook, returning it.
///
-/// *See also the function [`set_oom_hook`].*
+/// *See also the function [`set_alloc_error_hook`].*
///
/// If no custom hook is registered, the default hook will be returned.
-#[unstable(feature = "oom_hook", issue = "51245")]
-pub fn take_oom_hook() -> fn(Layout) {
+#[unstable(feature = "alloc_error_hook", issue = "51245")]
+pub fn take_alloc_error_hook() -> fn(Layout) {
let hook = HOOK.swap(ptr::null_mut(), Ordering::SeqCst);
if hook.is_null() {
- default_oom_hook
+ default_alloc_error_hook
} else {
unsafe { mem::transmute(hook) }
}
}
-fn default_oom_hook(layout: Layout) {
+fn default_alloc_error_hook(layout: Layout) {
dumb_print(format_args!("memory allocation of {} bytes failed", layout.size()));
}
pub extern fn rust_oom(layout: Layout) -> ! {
let hook = HOOK.load(Ordering::SeqCst);
let hook: fn(Layout) = if hook.is_null() {
- default_oom_hook
+ default_alloc_error_hook
} else {
unsafe { mem::transmute(hook) }
};
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use alloc::{Global, Alloc, Layout, LayoutErr, CollectionAllocErr, oom};
+use alloc::{Global, Alloc, Layout, LayoutErr, CollectionAllocErr, handle_alloc_error};
use hash::{BuildHasher, Hash, Hasher};
use marker;
use mem::{size_of, needs_drop};
// point into it.
let (layout, _) = calculate_layout::<K, V>(capacity)?;
let buffer = Global.alloc(layout).map_err(|e| match fallibility {
- Infallible => oom(layout),
+ Infallible => handle_alloc_error(layout),
Fallible => e,
})?;
#![feature(allocator_api, nonnull)]
-use std::alloc::{Alloc, Global, Layout, oom};
+use std::alloc::{Alloc, Global, Layout, handle_alloc_error};
fn main() {
unsafe {
- let ptr = Global.alloc_one::<i32>().unwrap_or_else(|_| oom(Layout::new::<i32>()));
+ let ptr = Global.alloc_one::<i32>().unwrap_or_else(|_| {
+ handle_alloc_error(Layout::new::<i32>())
+ });
*ptr.as_ptr() = 4;
assert_eq!(*ptr.as_ptr(), 4);
Global.dealloc_one(ptr);
#![feature(heap_api, allocator_api)]
-use std::alloc::{Global, Alloc, Layout, oom};
+use std::alloc::{Global, Alloc, Layout, handle_alloc_error};
use std::ptr::{self, NonNull};
fn main() {
println!("allocate({:?})", layout);
}
- let ret = Global.alloc(layout).unwrap_or_else(|_| oom(layout));
+ let ret = Global.alloc(layout).unwrap_or_else(|_| handle_alloc_error(layout));
if PRINT {
println!("allocate({:?}) = {:?}", layout, ret);
}
let ret = Global.realloc(NonNull::new_unchecked(ptr), old, new.size())
- .unwrap_or_else(|_| oom(Layout::from_size_align_unchecked(new.size(), old.align())));
+ .unwrap_or_else(|_| handle_alloc_error(
+ Layout::from_size_align_unchecked(new.size(), old.align())
+ ));
if PRINT {
println!("reallocate({:?}, old={:?}, new={:?}) = {:?}",
#![feature(allocator_api)]
-use std::alloc::{Alloc, Global, Layout, oom};
+use std::alloc::{Alloc, Global, Layout, handle_alloc_error};
use std::ptr::NonNull;
struct arena(());
fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> {
unsafe {
let layout = Layout::new::<Bcx>();
- let ptr = Global.alloc(layout).unwrap_or_else(|_| oom(layout));
+ let ptr = Global.alloc(layout).unwrap_or_else(|_| handle_alloc_error(layout));
&*(ptr.as_ptr() as *const _)
}
}
projects / rust.git / commitdiff