use an 'imp' module to reduce the amount of cfgs

src/liballoc/oom.rs

@@ -9,49 +9,54 @@
 // 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.
     unsafe { intrinsics::abort() }
 }
 
 /// 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()
+    }
 }