bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #50144 - sfackler:oom-lang-item, r=alexcrichton

Browse source 
Replace {Alloc,GlobalAlloc}::oom with a lang item.

The decision of what to do after an allocation fails is orthogonal to the decision of how to allocate the memory, so this PR splits them apart. `Alloc::oom` and `GlobalAlloc::oom` have been removed, and a lang item has been added:

```rust
#[lang = "oom"]
fn oom() -> !;
```

It is specifically a weak lang item, like panic_fmt, except that it is required when you depend on liballoc rather than libcore. libstd provides an implementation that aborts with the message `fatal runtime error: memory allocation failed`, matching the current behavior.

The new implementation is also significantly simpler - it's "just another weak lang item". [RFC 2070](https://github.com/rust-lang/rfcs/blob/master/text/2070-panic-implementation.md) specifies a path towards stabilizing panic_fmt, so any complexities around stable weak lang item definition are already being solved.

To bootstrap, oom silently aborts in stage0. alloc_system no longer has a bunch of code to print to stderr, and alloc_jemalloc no longer depends on alloc_system to pull in that code.

One fun note: System's GlobalAlloc implementation didn't override the default implementation of oom, so it currently aborts silently!

r? @alexcrichton
This commit is contained in:
bors 2018-04-22 19:38:32 +00:00
commit e02868793b
23 changed files with 61 additions and 177 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/Cargo.lock generated
View file

@ -19,7 +19,6 @@ dependencies = [
name = "alloc_jemalloc"
version = "0.0.0"
dependencies = [
"alloc_system 0.0.0",
"build_helper 0.1.0",
"cc 1.0.10 (registry+https://github.com/rust-lang/crates.io-index)",
"compiler_builtins 0.0.0",

38
src/liballoc/alloc.rs
View file

@ -48,9 +48,6 @@ extern "Rust" {
#[allocator]
#[rustc_allocator_nounwind]
fn __rust_alloc(size: usize, align: usize) -> *mut u8;
#[cold]
#[rustc_allocator_nounwind]
fn __rust_oom() -> !;
#[rustc_allocator_nounwind]
fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize);
#[rustc_allocator_nounwind]
@ -107,16 +104,6 @@ unsafe impl GlobalAlloc for Global {
let ptr = __rust_alloc_zeroed(layout.size(), layout.align(), &mut 0);
ptr as *mut Opaque
}
#[inline]
fn oom(&self) -> ! {
unsafe {
#[cfg(not(stage0))]
__rust_oom();
#[cfg(stage0)]
__rust_oom(&mut 0);
}
}
}
unsafe impl Alloc for Global {
@ -144,11 +131,6 @@ unsafe impl Alloc for Global {
unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<Opaque>, AllocErr> {
NonNull::new(GlobalAlloc::alloc_zeroed(self, layout)).ok_or(AllocErr)
}
#[inline]
fn oom(&mut self) -> ! {
GlobalAlloc::oom(self)
}
}
/// The allocator for unique pointers.
@ -165,7 +147,7 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
if !ptr.is_null() {
ptr as *mut u8
} else {
Global.oom()
oom()
}
}
}
@ -182,19 +164,33 @@ pub(crate) unsafe fn box_free<T: ?Sized>(ptr: *mut T) {
}
}
#[cfg(stage0)]
pub fn oom() -> ! {
unsafe { ::core::intrinsics::abort() }
}
#[cfg(not(stage0))]
pub fn oom() -> ! {
extern {
#[lang = "oom"]
fn oom_impl() -> !;
}
unsafe { oom_impl() }
}
#[cfg(test)]
mod tests {
extern crate test;
use self::test::Bencher;
use boxed::Box;
use alloc::{Global, Alloc, Layout};
use alloc::{Global, Alloc, Layout, oom};
#[test]
fn allocate_zeroed() {
unsafe {
let layout = Layout::from_size_align(1024, 1).unwrap();
let ptr = Global.alloc_zeroed(layout.clone())
.unwrap_or_else(|_| Global.oom());
.unwrap_or_else(|_| oom());
let mut i = ptr.cast::<u8>().as_ptr();
let end = i.offset(layout.size() as isize);

4
src/liballoc/arc.rs
View file

@ -31,7 +31,7 @@ use core::hash::{Hash, Hasher};
use core::{isize, usize};
use core::convert::From;
use alloc::{Global, Alloc, Layout, box_free};
use alloc::{Global, Alloc, Layout, box_free, oom};
use boxed::Box;
use string::String;
use vec::Vec;
@ -553,7 +553,7 @@ impl<T: ?Sized> Arc<T> {
let layout = Layout::for_value(&*fake_ptr);
let mem = Global.alloc(layout)
.unwrap_or_else(|_| Global.oom());
.unwrap_or_else(|_| oom());
// Initialize the real ArcInner
let inner = set_data_ptr(ptr as *mut T, mem.as_ptr() as *mut u8) as *mut ArcInner<T>;

2
src/liballoc/heap.rs
View file

@ -59,7 +59,7 @@ unsafe impl<T> Alloc for T where T: CoreAlloc {
}
fn oom(&mut self, _: AllocErr) -> ! {
CoreAlloc::oom(self)
unsafe { ::core::intrinsics::abort() }
}
fn usable_size(&self, layout: &Layout) -> (usize, usize) {

14
src/liballoc/raw_vec.rs
View file

@ -14,7 +14,7 @@ use core::ops::Drop;
use core::ptr::{self, NonNull, Unique};
use core::slice;
use alloc::{Alloc, Layout, Global};
use alloc::{Alloc, Layout, Global, oom};
use alloc::CollectionAllocErr;
use alloc::CollectionAllocErr::*;
use boxed::Box;
@ -101,7 +101,7 @@ impl<T, A: Alloc> RawVec<T, A> {
};
match result {
Ok(ptr) => ptr,
Err(_) => a.oom(),
Err(_) => oom(),
}
};
@ -316,7 +316,7 @@ impl<T, A: Alloc> RawVec<T, A> {
new_size);
match ptr_res {
Ok(ptr) => (new_cap, ptr.cast().into()),
Err(_) => self.a.oom(),
Err(_) => oom(),
}
}
None => {
@ -325,7 +325,7 @@ impl<T, A: Alloc> RawVec<T, A> {
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(_) => self.a.oom(),
Err(_) => oom(),
}
}
};
@ -442,7 +442,7 @@ impl<T, A: Alloc> RawVec<T, A> {
pub fn reserve_exact(&mut self, used_cap: usize, needed_extra_cap: usize) {
match self.try_reserve_exact(used_cap, needed_extra_cap) {
Err(CapacityOverflow) => capacity_overflow(),
Err(AllocErr) => self.a.oom(),
Err(AllocErr) => oom(),
Ok(()) => { /* yay */ }
}
}
@ -552,7 +552,7 @@ impl<T, A: Alloc> RawVec<T, A> {
pub fn reserve(&mut self, used_cap: usize, needed_extra_cap: usize) {
match self.try_reserve(used_cap, needed_extra_cap) {
Err(CapacityOverflow) => capacity_overflow(),
Err(AllocErr) => self.a.oom(),
Err(AllocErr) => oom(),
Ok(()) => { /* yay */ }
}
}
@ -667,7 +667,7 @@ impl<T, A: Alloc> RawVec<T, A> {
old_layout,
new_size) {
Ok(p) => self.ptr = p.cast().into(),
Err(_) => self.a.oom(),
Err(_) => oom(),
}
}
self.cap = amount;

4
src/liballoc/rc.rs
View file

@ -259,7 +259,7 @@ use core::ops::CoerceUnsized;
use core::ptr::{self, NonNull};
use core::convert::From;
use alloc::{Global, Alloc, Layout, Opaque, box_free};
use alloc::{Global, Alloc, Layout, Opaque, box_free, oom};
use string::String;
use vec::Vec;
@ -668,7 +668,7 @@ impl<T: ?Sized> Rc<T> {
let layout = Layout::for_value(&*fake_ptr);
let mem = Global.alloc(layout)
.unwrap_or_else(|_| Global.oom());
.unwrap_or_else(|_| oom());
// Initialize the real RcBox
let inner = set_data_ptr(ptr as *mut T, mem.as_ptr() as *mut u8) as *mut RcBox<T>;

1
src/liballoc_jemalloc/Cargo.toml
View file

@ -12,7 +12,6 @@ test = false
doc = false
[dependencies]
alloc_system = { path = "../liballoc_system" }
core = { path = "../libcore" }
libc = { path = "../rustc/libc_shim" }
compiler_builtins = { path = "../rustc/compiler_builtins_shim" }

8
src/liballoc_jemalloc/lib.rs
View file

@ -14,7 +14,7 @@
reason = "this library is unlikely to be stabilized in its current \
form or name",
issue = "27783")]
#![feature(alloc_system)]
#![feature(core_intrinsics)]
#![feature(libc)]
#![feature(linkage)]
#![feature(staged_api)]
@ -23,15 +23,12 @@
#![cfg_attr(not(dummy_jemalloc), feature(allocator_api))]
#![rustc_alloc_kind = "exe"]
extern crate alloc_system;
extern crate libc;
#[cfg(not(dummy_jemalloc))]
pub use contents::*;
#[cfg(not(dummy_jemalloc))]
mod contents {
use core::alloc::GlobalAlloc;
use alloc_system::System;
use libc::{c_int, c_void, size_t};
// Note that the symbols here are prefixed by default on macOS and Windows (we
@ -100,10 +97,11 @@ mod contents {
ptr
}
#[cfg(stage0)]
#[no_mangle]
#[rustc_std_internal_symbol]
pub unsafe extern fn __rde_oom() -> ! {
System.oom()
::core::intrinsics::abort();
}
#[no_mangle]

70
src/liballoc_system/lib.rs
View file

@ -71,11 +71,6 @@ unsafe impl Alloc for System {
new_size: usize) -> Result<NonNull<Opaque>, AllocErr> {
NonNull::new(GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)
}
#[inline]
fn oom(&mut self) -> ! {
::oom()
}
}
#[cfg(stage0)]
@ -103,11 +98,6 @@ unsafe impl<'a> Alloc for &'a System {
new_size: usize) -> Result<NonNull<Opaque>, AllocErr> {
NonNull::new(GlobalAlloc::realloc(*self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)
}
#[inline]
fn oom(&mut self) -> ! {
::oom()
}
}
#[cfg(any(windows, unix, target_os = "cloudabi", target_os = "redox"))]
@ -366,63 +356,3 @@ mod platform {
}
}
}
#[inline]
fn oom() -> ! {
write_to_stderr("fatal runtime error: memory allocation failed");
unsafe {
::core::intrinsics::abort();
}
}
#[cfg(any(unix, target_os = "redox"))]
#[inline]
fn write_to_stderr(s: &str) {
extern crate libc;
unsafe {
libc::write(libc::STDERR_FILENO,
s.as_ptr() as *const libc::c_void,
s.len());
}
}
#[cfg(windows)]
#[inline]
fn write_to_stderr(s: &str) {
use core::ptr;
type LPVOID = *mut u8;
type HANDLE = LPVOID;
type DWORD = u32;
type BOOL = i32;
type LPDWORD = *mut DWORD;
type LPOVERLAPPED = *mut u8;
const STD_ERROR_HANDLE: DWORD = -12i32 as DWORD;
extern "system" {
fn WriteFile(hFile: HANDLE,
lpBuffer: LPVOID,
nNumberOfBytesToWrite: DWORD,
lpNumberOfBytesWritten: LPDWORD,
lpOverlapped: LPOVERLAPPED)
-> BOOL;
fn GetStdHandle(which: DWORD) -> HANDLE;
}
unsafe {
// WriteFile silently fails if it is passed an invalid
// handle, so there is no need to check the result of
// GetStdHandle.
WriteFile(GetStdHandle(STD_ERROR_HANDLE),
s.as_ptr() as LPVOID,
s.len() as DWORD,
ptr::null_mut(),
ptr::null_mut());
}
}
#[cfg(not(any(windows, unix, target_os = "redox")))]
#[inline]
fn write_to_stderr(_: &str) {}

37
src/libcore/alloc.rs
View file

@ -451,17 +451,6 @@ pub unsafe trait GlobalAlloc {
}
new_ptr
}
/// Aborts the thread or process, optionally performing
/// cleanup or logging diagnostic information before panicking or
/// aborting.
///
/// `oom` is meant to be used by clients unable to cope with an
/// unsatisfied allocation request, and wish to abandon
/// computation rather than attempt to recover locally.
fn oom(&self) -> ! {
unsafe { ::intrinsics::abort() }
}
}
/// An implementation of `Alloc` can allocate, reallocate, and
@ -614,32 +603,6 @@ pub unsafe trait Alloc {
/// to allocate that block of memory.
unsafe fn dealloc(&mut self, ptr: NonNull<Opaque>, layout: Layout);
/// Allocator-specific method for signaling an out-of-memory
/// condition.
///
/// `oom` aborts the thread or process, optionally performing
/// cleanup or logging diagnostic information before panicking or
/// aborting.
///
/// `oom` is meant to be used by clients unable to cope with an
/// unsatisfied allocation request, and wish to abandon
/// computation rather than attempt to recover locally.
///
/// Implementations of the `oom` method are discouraged from
/// infinitely regressing in nested calls to `oom`. In
/// practice this means implementors should eschew allocating,
/// especially from `self` (directly or indirectly).
///
/// Implementations of the allocation and reallocation methods
/// (e.g. `alloc`, `alloc_one`, `realloc`) are discouraged from
/// panicking (or aborting) in the event of memory exhaustion;
/// instead they should return an appropriate error from the
/// invoked method, and let the client decide whether to invoke
/// this `oom` method in response.
fn oom(&mut self) -> ! {
unsafe { ::intrinsics::abort() }
}
// == ALLOCATOR-SPECIFIC QUANTITIES AND LIMITS ==
// usable_size

3
src/librustc/middle/lang_items.rs
View file

@ -303,7 +303,8 @@ language_item_table! {
ExchangeMallocFnLangItem, "exchange_malloc", exchange_malloc_fn;
BoxFreeFnLangItem, "box_free", box_free_fn;
DropInPlaceFnLangItem, "drop_in_place", drop_in_place_fn;
DropInPlaceFnLangItem, "drop_in_place", drop_in_place_fn;
OomLangItem, "oom", oom;
StartFnLangItem, "start", start_fn;

1
src/librustc/middle/weak_lang_items.rs
View file

@ -151,4 +151,5 @@ weak_lang_items! {
panic_fmt, PanicFmtLangItem, rust_begin_unwind;
eh_personality, EhPersonalityLangItem, rust_eh_personality;
eh_unwind_resume, EhUnwindResumeLangItem, rust_eh_unwind_resume;
oom, OomLangItem, rust_oom;
}

4
src/librustc_allocator/expand.rs
View file

@ -245,7 +245,7 @@ impl<'a> AllocFnFactory<'a> {
self.cx.expr_ident(self.span, ident)
}
AllocatorTy::ResultPtr | AllocatorTy::Bang | AllocatorTy::Unit => {
AllocatorTy::ResultPtr | AllocatorTy::Unit => {
panic!("can't convert AllocatorTy to an argument")
}
}
@ -262,8 +262,6 @@ impl<'a> AllocFnFactory<'a> {
(self.ptr_u8(), expr)
}
AllocatorTy::Bang => (self.cx.ty(self.span, TyKind::Never), expr),
AllocatorTy::Unit => (self.cx.ty(self.span, TyKind::Tup(Vec::new())), expr),
AllocatorTy::Layout | AllocatorTy::Usize | AllocatorTy::Ptr => {

6
src/librustc_allocator/lib.rs
View file

@ -23,11 +23,6 @@ pub static ALLOCATOR_METHODS: &[AllocatorMethod] = &[
inputs: &[AllocatorTy::Layout],
output: AllocatorTy::ResultPtr,
},
AllocatorMethod {
name: "oom",
inputs: &[],
output: AllocatorTy::Bang,
},
AllocatorMethod {
name: "dealloc",
inputs: &[AllocatorTy::Ptr, AllocatorTy::Layout],
@ -52,7 +47,6 @@ pub struct AllocatorMethod {
}
pub enum AllocatorTy {
Bang,
Layout,
Ptr,
ResultPtr,

2
src/librustc_trans/allocator.rs
View file

@ -43,13 +43,11 @@ pub(crate) unsafe fn trans(tcx: TyCtxt, mods: &ModuleLlvm, kind: AllocatorKind)
AllocatorTy::Ptr => args.push(i8p),
AllocatorTy::Usize => args.push(usize),
AllocatorTy::Bang |
AllocatorTy::ResultPtr |
AllocatorTy::Unit => panic!("invalid allocator arg"),
}
}
let output = match method.output {
AllocatorTy::Bang => None,
AllocatorTy::ResultPtr => Some(i8p),
AllocatorTy::Unit => None,

13
src/libstd/alloc.rs
View file

@ -13,10 +13,18 @@
#![unstable(issue = "32838", feature = "allocator_api")]
#[doc(inline)] #[allow(deprecated)] pub use alloc_crate::alloc::Heap;
#[doc(inline)] pub use alloc_crate::alloc::Global;
#[doc(inline)] pub use alloc_crate::alloc::{Global, oom};
#[doc(inline)] pub use alloc_system::System;
#[doc(inline)] pub use core::alloc::*;
#[cfg(not(stage0))]
#[cfg(not(test))]
#[doc(hidden)]
#[lang = "oom"]
pub extern fn rust_oom() -> ! {
rtabort!("memory allocation failed");
}
#[cfg(not(test))]
#[doc(hidden)]
#[allow(unused_attributes)]
@ -35,10 +43,11 @@ pub mod __default_lib_allocator {
System.alloc(layout) as *mut u8
}
#[cfg(stage0)]
#[no_mangle]
#[rustc_std_internal_symbol]
pub unsafe extern fn __rdl_oom() -> ! {
System.oom()
super::oom()
}
#[no_mangle]

4
src/libstd/collections/hash/map.rs
View file

@ -11,7 +11,7 @@
use self::Entry::*;
use self::VacantEntryState::*;
use alloc::{Global, Alloc, CollectionAllocErr};
use alloc::{CollectionAllocErr, oom};
use cell::Cell;
use borrow::Borrow;
use cmp::max;
@ -784,7 +784,7 @@ impl<K, V, S> HashMap<K, V, S>
pub fn reserve(&mut self, additional: usize) {
match self.try_reserve(additional) {
Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
Err(CollectionAllocErr::AllocErr) => Global.oom(),
Err(CollectionAllocErr::AllocErr) => oom(),
Ok(()) => { /* yay */ }
}
}

6
src/libstd/collections/hash/table.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use alloc::{Global, Alloc, Layout, CollectionAllocErr};
use alloc::{Global, Alloc, Layout, CollectionAllocErr, oom};
use cmp;
use hash::{BuildHasher, Hash, Hasher};
use marker;
@ -770,7 +770,7 @@ impl<K, V> RawTable<K, V> {
unsafe fn new_uninitialized(capacity: usize) -> RawTable<K, V> {
match Self::try_new_uninitialized(capacity) {
Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
Err(CollectionAllocErr::AllocErr) => Global.oom(),
Err(CollectionAllocErr::AllocErr) => oom(),
Ok(table) => { table }
}
}
@ -809,7 +809,7 @@ impl<K, V> RawTable<K, V> {
pub fn new(capacity: usize) -> RawTable<K, V> {
match Self::try_new(capacity) {
Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
Err(CollectionAllocErr::AllocErr) => Global.oom(),
Err(CollectionAllocErr::AllocErr) => oom(),
Ok(table) => { table }
}
}

3
src/libstd/lib.rs
View file

@ -482,7 +482,6 @@ pub mod path;
pub mod process;
pub mod sync;
pub mod time;
pub mod alloc;
#[unstable(feature = "allocator_api", issue = "32838")]
#[rustc_deprecated(since = "1.27.0", reason = "module renamed to `alloc`")]
@ -496,6 +495,8 @@ pub mod heap {
mod sys_common;
mod sys;
pub mod alloc;
// Private support modules
mod panicking;
mod memchr;

1
src/test/compile-fail/allocator/not-an-allocator.rs
View file

@ -16,6 +16,5 @@ static A: usize = 0;
//~| the trait bound `usize:
//~| the trait bound `usize:
//~| the trait bound `usize:
//~| the trait bound `usize:
fn main() {}

6
src/test/run-pass/allocator-alloc-one.rs
View file

@ -10,13 +10,11 @@
#![feature(allocator_api, nonnull)]
use std::alloc::{Alloc, Global};
use std::alloc::{Alloc, Global, oom};
fn main() {
unsafe {
let ptr = Global.alloc_one::<i32>().unwrap_or_else(|_| {
Global.oom()
});
let ptr = Global.alloc_one::<i32>().unwrap_or_else(|_| oom());
*ptr.as_ptr() = 4;
assert_eq!(*ptr.as_ptr(), 4);
Global.dealloc_one(ptr);

6
src/test/run-pass/realloc-16687.rs
View file

@ -15,7 +15,7 @@
#![feature(heap_api, allocator_api)]
use std::alloc::{Global, Alloc, Layout};
use std::alloc::{Global, Alloc, Layout, oom};
use std::ptr::{self, NonNull};
fn main() {
@ -50,7 +50,7 @@ unsafe fn test_triangle() -> bool {
println!("allocate({:?})", layout);
}
let ret = Global.alloc(layout.clone()).unwrap_or_else(|_| Global.oom());
let ret = Global.alloc(layout.clone()).unwrap_or_else(|_| oom());
if PRINT {
println!("allocate({:?}) = {:?}", layout, ret);
@ -73,7 +73,7 @@ unsafe fn test_triangle() -> bool {
}
let ret = Global.realloc(NonNull::new_unchecked(ptr).as_opaque(), old.clone(), new.size())
.unwrap_or_else(|_| Global.oom());
.unwrap_or_else(|_| oom());
if PRINT {
println!("reallocate({:?}, old={:?}, new={:?}) = {:?}",

4
src/test/run-pass/regions-mock-trans.rs
View file

@ -12,7 +12,7 @@
#![feature(allocator_api)]
use std::alloc::{Alloc, Global, Layout};
use std::alloc::{Alloc, Global, Layout, oom};
use std::ptr::NonNull;
struct arena(());
@ -33,7 +33,7 @@ struct Ccx {
fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> {
unsafe {
let ptr = Global.alloc(Layout::new::<Bcx>())
.unwrap_or_else(|_| Global.oom());
.unwrap_or_else(|_| oom());
&*(ptr.as_ptr() as *const _)
}
}