From 907d2a1aeb26151cc81dfa148e874e4fe50d1a14 Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Sun, 30 Oct 2016 22:14:05 -0500 Subject: [PATCH 1/3] make `alloc` and `collections` compilable for thumbv6m-none-eabi by cfging away `alloc::Arc` and changing OOM to abort for this target --- src/liballoc/lib.rs | 2 ++ src/liballoc/oom.rs | 15 +++++++++++++++ 2 files changed, 17 insertions(+) diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index 31491106d97ee..dd22894ea95b2 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -74,6 +74,7 @@ #![feature(allocator)] #![feature(box_syntax)] +#![feature(cfg_target_has_atomic)] #![feature(coerce_unsized)] #![feature(const_fn)] #![feature(core_intrinsics)] @@ -117,6 +118,7 @@ mod boxed { } #[cfg(test)] mod boxed_test; +#[cfg(target_has_atomic = "ptr")] pub mod arc; pub mod rc; pub mod raw_vec; diff --git a/src/liballoc/oom.rs b/src/liballoc/oom.rs index d355d59185eb4..afdc19678dc19 100644 --- a/src/liballoc/oom.rs +++ b/src/liballoc/oom.rs @@ -8,10 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#[cfg(target_has_atomic = "ptr")] use core::sync::atomic::{AtomicPtr, Ordering}; +#[cfg(target_has_atomic = "ptr")] use core::mem; use core::intrinsics; +#[cfg(target_has_atomic = "ptr")] static OOM_HANDLER: AtomicPtr<()> = AtomicPtr::new(default_oom_handler as *mut ()); fn default_oom_handler() -> ! { @@ -21,6 +24,7 @@ fn default_oom_handler() -> ! { } /// Common out-of-memory routine +#[cfg(target_has_atomic = "ptr")] #[cold] #[inline(never)] #[unstable(feature = "oom", reason = "not a scrutinized interface", @@ -31,10 +35,21 @@ pub fn oom() -> ! { handler(); } +/// Common out-of-memory routine +#[cfg(not(target_has_atomic = "ptr"))] +#[cold] +#[inline(never)] +#[unstable(feature = "oom", reason = "not a scrutinized interface", + issue = "27700")] +pub fn oom() -> ! { + default_oom_handler() +} + /// Set a custom handler for out-of-memory conditions /// /// To avoid recursive OOM failures, it is critical that the OOM handler does /// not allocate any memory itself. +#[cfg(target_has_atomic = "ptr")] #[unstable(feature = "oom", reason = "not a scrutinized interface", issue = "27700")] pub fn set_oom_handler(handler: fn() -> !) { From 24dc2bc3f5946927784bf1924041035be07474b2 Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Thu, 10 Nov 2016 23:42:59 -0500 Subject: [PATCH 2/3] use an 'imp' module to reduce the amount of cfgs --- src/liballoc/oom.rs | 59 ++++++++++++++++++++++++--------------------- 1 file changed, 32 insertions(+), 27 deletions(-) diff --git a/src/liballoc/oom.rs b/src/liballoc/oom.rs index afdc19678dc19..87ae16f6c53ad 100644 --- a/src/liballoc/oom.rs +++ b/src/liballoc/oom.rs @@ -9,14 +9,9 @@ // except according to those terms. #[cfg(target_has_atomic = "ptr")] -use core::sync::atomic::{AtomicPtr, Ordering}; -#[cfg(target_has_atomic = "ptr")] -use core::mem; +pub use self::imp::set_oom_handler; use core::intrinsics; -#[cfg(target_has_atomic = "ptr")] -static OOM_HANDLER: AtomicPtr<()> = AtomicPtr::new(default_oom_handler as *mut ()); - fn default_oom_handler() -> ! { // The default handler can't do much more since we can't assume the presence // of libc or any way of printing an error message. @@ -24,34 +19,44 @@ fn default_oom_handler() -> ! { } /// Common out-of-memory routine -#[cfg(target_has_atomic = "ptr")] #[cold] #[inline(never)] #[unstable(feature = "oom", reason = "not a scrutinized interface", issue = "27700")] pub fn oom() -> ! { - let value = OOM_HANDLER.load(Ordering::SeqCst); - let handler: fn() -> ! = unsafe { mem::transmute(value) }; - handler(); + self::imp::oom() } -/// Common out-of-memory routine -#[cfg(not(target_has_atomic = "ptr"))] -#[cold] -#[inline(never)] -#[unstable(feature = "oom", reason = "not a scrutinized interface", - issue = "27700")] -pub fn oom() -> ! { - default_oom_handler() +#[cfg(target_has_atomic = "ptr")] +mod imp { + use core::mem; + use core::sync::atomic::{AtomicPtr, Ordering}; + + static OOM_HANDLER: AtomicPtr<()> = AtomicPtr::new(super::default_oom_handler as *mut ()); + + #[inline(always)] + pub fn oom() -> ! { + let value = OOM_HANDLER.load(Ordering::SeqCst); + let handler: fn() -> ! = unsafe { mem::transmute(value) }; + handler(); + } + + /// Set a custom handler for out-of-memory conditions + /// + /// To avoid recursive OOM failures, it is critical that the OOM handler does + /// not allocate any memory itself. + #[unstable(feature = "oom", reason = "not a scrutinized interface", + issue = "27700")] + pub fn set_oom_handler(handler: fn() -> !) { + OOM_HANDLER.store(handler as *mut (), Ordering::SeqCst); + } + } -/// Set a custom handler for out-of-memory conditions -/// -/// To avoid recursive OOM failures, it is critical that the OOM handler does -/// not allocate any memory itself. -#[cfg(target_has_atomic = "ptr")] -#[unstable(feature = "oom", reason = "not a scrutinized interface", - issue = "27700")] -pub fn set_oom_handler(handler: fn() -> !) { - OOM_HANDLER.store(handler as *mut (), Ordering::SeqCst); +#[cfg(not(target_has_atomic = "ptr"))] +mod imp { + #[inline(always)] + pub fn oom() -> ! { + super::default_oom_handler() + } } From abe6fc73e0d5d58d12b069a8b27514086ebbefa1 Mon Sep 17 00:00:00 2001 From: Jorge Aparicio Date: Thu, 10 Nov 2016 23:44:15 -0500 Subject: [PATCH 3/3] drop an unnecessary newline --- src/liballoc/oom.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/liballoc/oom.rs b/src/liballoc/oom.rs index 87ae16f6c53ad..3640156fec2ae 100644 --- a/src/liballoc/oom.rs +++ b/src/liballoc/oom.rs @@ -50,7 +50,6 @@ mod imp { pub fn set_oom_handler(handler: fn() -> !) { OOM_HANDLER.store(handler as *mut (), Ordering::SeqCst); } - } #[cfg(not(target_has_atomic = "ptr"))]