From 24dc2bc3f5946927784bf1924041035be07474b2 Mon Sep 17 00:00:00 2001
From: Jorge Aparicio <japaricious@gmail.com>
Date: Thu, 10 Nov 2016 23:42:59 -0500
Subject: [PATCH] use an 'imp' module to reduce the amount of cfgs

---
 src/liballoc/oom.rs | 61 ++++++++++++++++++++++++---------------------
 1 file changed, 33 insertions(+), 28 deletions(-)

diff --git a/src/liballoc/oom.rs b/src/liballoc/oom.rs
index afdc19678dc..87ae16f6c53 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()
+}
+
+#[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);
+    }
+
 }
 
-/// 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() -> !) {
-    OOM_HANDLER.store(handler as *mut (), Ordering::SeqCst);
+mod imp {
+    #[inline(always)]
+    pub fn oom() -> ! {
+        super::default_oom_handler()
+    }
 }