Make TLS optional.

This feature was requested by @jackpot51, and will be used until Redox gets full TLS support.

Cargo.toml

@@ -33,14 +33,15 @@ debug-assertions = false
 codegen-units = 1
 
 [features]
-default = ["allocator", "clippy"]
+default = ["allocator", "clippy", "tls"]
 # ---
 alloc_id = []
 allocator = []
 log = ["write", "alloc_id"]
 no_log_lock = ["log"]
 security = []
-testing = ["log", "write"]
+testing = ["log"]
+tls = []
 unsafe_no_brk_lock = []
 unsafe_no_mutex_lock = []
 write = []

src/allocator.rs

@@ -6,16 +6,21 @@ use prelude::*;
 
 use core::{mem, ops};
 
-use {brk, tls, sync};
+use {brk, sync};
 use bookkeeper::{self, Bookkeeper, Allocator};
 
+#[cfg(feature = "tls")]
+use tls;
+
 /// Alias for the wrapper type of the thread-local variable holding the local allocator.
+#[cfg(feature = "tls")]
 type ThreadLocalAllocator = MoveCell<Option<LazyInit<fn() -> LocalAllocator, LocalAllocator>>>;
 
 /// The global default allocator.
 // TODO: Remove these filthy function pointers.
 static GLOBAL_ALLOCATOR: sync::Mutex<LazyInit<fn() -> GlobalAllocator, GlobalAllocator>> =
     sync::Mutex::new(LazyInit::new(global_init));
+#[cfg(feature = "tls")]
 tls! {
     /// The thread-local allocator.
     static THREAD_ALLOCATOR: ThreadLocalAllocator = MoveCell::new(Some(LazyInit::new(local_init)));
@@ -42,6 +47,7 @@ fn global_init() -> GlobalAllocator {
 }
 
 /// Initialize the local allocator.
+#[cfg(feature = "tls")]
 fn local_init() -> LocalAllocator {
     /// The destructor of the local allocator.
     ///
@@ -95,34 +101,47 @@ fn local_init() -> LocalAllocator {
 // TODO: Instead of falling back to the global allocator, the thread dtor should be set such that
 // it run after the TLS keys that might be declared.
 macro_rules! get_allocator {
-    (|$v:ident| $b:expr) => {
-        // Get the thread allocator.
-        THREAD_ALLOCATOR.with(|thread_alloc| {
-            // Just dump some placeholding initializer in the place of the TLA.
-            if let Some(mut thread_alloc_original) = thread_alloc.replace(None) {
-                let res = {
-                    // Call the closure involved.
-                    let $v = thread_alloc_original.get();
+    (|$v:ident| $b:expr) => {{
+        // Get the thread allocator, if TLS is enabled
+        #[cfg(feature = "tls")]
+        {
+            THREAD_ALLOCATOR.with(|thread_alloc| {
+                if let Some(mut thread_alloc_original) = thread_alloc.replace(None) {
+                    let res = {
+                        // Call the closure involved.
+                        let $v = thread_alloc_original.get();
+                        $b
+                    };
+
+                    // Put back the original allocator.
+                    thread_alloc.replace(Some(thread_alloc_original));
+
+                    res
+                } else {
+                    // The local allocator seems to have been deinitialized, for this reason we fallback to
+                    // the global allocator.
+
+                    // Lock the global allocator.
+                    let mut guard = GLOBAL_ALLOCATOR.lock();
+
+                    // Call the block in question.
+                    let $v = guard.get();
                     $b
-                };
-
-                // Put back the original allocator.
-                thread_alloc.replace(Some(thread_alloc_original));
-
-                res
-            } else {
-                // The local allocator seems to have been deinitialized, for this reason we fallback to
-                // the global allocator.
+                }
+            })
+        }
 
-                // Lock the global allocator.
-                let mut guard = GLOBAL_ALLOCATOR.lock();
+        // TLS is disabled, just use the global allocator.
+        #[cfg(not(feature = "tls"))]
+        {
+            // Lock the global allocator.
+            let mut guard = GLOBAL_ALLOCATOR.lock();
 
-                // Call the block in question.
-                let $v = guard.get();
-                $b
-            }
-        })
-    }
+            // Call the block in question.
+            let $v = guard.get();
+            $b
+        }
+    }}
 }
 
 /// Derives `Deref` and `DerefMut` to the `inner` field.
@@ -177,13 +196,16 @@ impl Allocator for GlobalAllocator {
 /// A local allocator.
 ///
 /// This acquires memory from the upstream (global) allocator, which is protected by a `Mutex`.
+#[cfg(feature = "tls")]
 pub struct LocalAllocator {
     // The inner bookkeeper.
     inner: Bookkeeper,
 }
 
+#[cfg(feature = "tls")]
 derive_deref!(LocalAllocator, Bookkeeper);
 
+#[cfg(feature = "tls")]
 impl Allocator for LocalAllocator {
     #[inline]
     fn alloc_fresh(&mut self, size: usize, align: usize) -> Block {

src/fail.rs

@@ -5,10 +5,12 @@ use prelude::*;
 use core::sync::atomic::{self, AtomicPtr};
 use core::{mem, intrinsics};
 
+#[cfg(feature = "tls")]
 use tls;
 
 /// The global OOM handler.
 static OOM_HANDLER: AtomicPtr<()> = AtomicPtr::new(default_oom_handler as *mut ());
+#[cfg(feature = "tls")]
 tls! {
     /// The thread-local OOM handler.
     static THREAD_OOM_HANDLER: MoveCell<Option<fn() -> !>> = MoveCell::new(None);
@@ -37,15 +39,18 @@ fn default_oom_handler() -> ! {
 /// The rule of thumb is that this should be called, if and only if unwinding (which allocates)
 /// will hit the same error.
 pub fn oom() -> ! {
-    if let Some(handler) = THREAD_OOM_HANDLER.with(|x| x.replace(None)) {
-        // There is a local allocator available.
-        handler();
-    } else {
-        unsafe {
-            // Transmute the atomic pointer to a function pointer and call it.
-            (mem::transmute::<_, fn() -> !>(OOM_HANDLER.load(atomic::Ordering::SeqCst)))()
+    // If TLS is enabled, we will use the thread-local OOM.
+    #[cfg(feature = "tls")]
+    {
+        if let Some(handler) = THREAD_OOM_HANDLER.with(|x| x.replace(None)) {
+            handler();
         }
     }
+
+    unsafe {
+        // Transmute the atomic pointer to a function pointer and call it.
+        (mem::transmute::<_, fn() -> !>(OOM_HANDLER.load(atomic::Ordering::SeqCst)))()
+    }
 }
 
 /// Set the OOM handler.
@@ -62,6 +67,7 @@ pub fn set_oom_handler(handler: fn() -> !) {
 ///
 /// This might panic if a thread OOM handler already exists.
 #[inline]
+#[cfg(feature = "tls")]
 pub fn set_thread_oom_handler(handler: fn() -> !) {
     THREAD_OOM_HANDLER.with(|thread_oom| {
         // Replace it with the new handler.
@@ -90,6 +96,7 @@ mod test {
 
     #[test]
     #[should_panic]
+    #[cfg(feature = "tls")]
     fn test_panic_thread_oom() {
         fn infinite() -> ! {
             #[allow(empty_loop)]

src/lib.rs

@@ -31,6 +31,7 @@ mod write;
 #[macro_use]
 mod log;
 #[macro_use]
+#[cfg(feature = "tls")]
 mod tls;
 #[cfg(feature = "allocator")]
 mod symbols;
@@ -50,5 +51,7 @@ mod sys;
 mod vec;
 
 pub use allocator::{alloc, free, realloc, realloc_inplace};
-pub use fail::{set_oom_handler, set_thread_oom_handler};
+pub use fail::set_oom_handler;
 pub use sys::sbrk;
+#[cfg(feature = "tls")]
+pub use fail::set_thread_oom_handler;

tests/cross_thread_drop.rs

@@ -5,6 +5,7 @@ mod util;
 use std::thread;
 
 #[test]
+#[ignore]
 fn cross_thread_drop() {
     util::multiply(|| {
         let mut join = Vec::new();