Work around lack of __thread on iOS. Based on patch from Jason Choy (@jjwchoy).

c++/Makefile.am

@@ -138,6 +138,7 @@ includekj_HEADERS =                                            \
   src/kj/function.h                                            \
   src/kj/mutex.h                                               \
   src/kj/thread.h                                              \
+  src/kj/threadlocal.h                                         \
   src/kj/async-prelude.h                                       \
   src/kj/async.h                                               \
   src/kj/async-inl.h                                           \
@@ -347,6 +348,8 @@ capnp_test_SOURCES =                                           \
   src/kj/one-of-test.c++                                       \
   src/kj/function-test.c++                                     \
   src/kj/mutex-test.c++                                        \
+  src/kj/threadlocal-test.c++                                  \
+  src/kj/threadlocal-pthread-test.c++                          \
   src/kj/async-test.c++                                        \
   src/kj/async-unix-test.c++                                   \
   src/kj/async-io-test.c++                                     \

c++/src/capnp/ez-rpc.c++

@@ -26,11 +26,12 @@
 #include <capnp/rpc.capnp.h>
 #include <kj/async-io.h>
 #include <kj/debug.h>
+#include <kj/threadlocal.h>
 #include <map>
 
 namespace capnp {
 
-static __thread EzRpcContext* threadEzContext = nullptr;
+KJ_THREADLOCAL_PTR(EzRpcContext) threadEzContext = nullptr;
 
 class EzRpcContext: public kj::Refcounted {
 public:

c++/src/kj/async-unix.c++

@@ -23,6 +23,7 @@
 
 #include "async-unix.h"
 #include "debug.h"
+#include "threadlocal.h"
 #include <setjmp.h>
 #include <errno.h>
 
@@ -40,7 +41,7 @@ struct SignalCapture {
   siginfo_t siginfo;
 };
 
-__thread SignalCapture* threadCapture = nullptr;
+KJ_THREADLOCAL_PTR(SignalCapture) threadCapture = nullptr;
 
 void signalHandler(int, siginfo_t* siginfo, void*) {
   SignalCapture* capture = threadCapture;

c++/src/kj/async.c++

@@ -24,6 +24,7 @@
 #include "async.h"
 #include "debug.h"
 #include "vector.h"
+#include "threadlocal.h"
 #include <exception>
 #include <map>
 
@@ -45,7 +46,7 @@ namespace kj {
 
 namespace {
 
-static __thread EventLoop* threadLocalEventLoop = nullptr;
+KJ_THREADLOCAL_PTR(EventLoop) threadLocalEventLoop = nullptr;
 
 #define _kJ_ALREADY_READY reinterpret_cast< ::kj::_::Event*>(1)
 

c++/src/kj/exception.c++

@@ -24,6 +24,7 @@
 #include "exception.h"
 #include "string.h"
 #include "debug.h"
+#include "threadlocal.h"
 #include <unistd.h>
 #include <stdlib.h>
 #include <exception>
@@ -247,7 +248,7 @@ const char* ExceptionImpl::what() const noexcept {
 
 namespace {
 
-static __thread ExceptionCallback* threadLocalCallback = nullptr;
+KJ_THREADLOCAL_PTR(ExceptionCallback) threadLocalCallback = nullptr;
 
 }  // namespace
 

c++/src/kj/threadlocal-pthread-test.c++

+// Copyright (c) 2014, Kenton Varda <temporal@gmail.com>
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#define KJ_USE_PTHREAD_TLS 1
+#include "threadlocal-test.c++"

c++/src/kj/threadlocal-test.c++

+// Copyright (c) 2014, Kenton Varda <temporal@gmail.com>
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "threadlocal.h"
+#include "debug.h"
+#include "thread.h"
+#include <gtest/gtest.h>
+
+namespace kj {
+namespace {
+
+KJ_THREADLOCAL_PTR(uint) tls1 = nullptr;
+KJ_THREADLOCAL_PTR(uint) tls2;
+
+TEST(ThreadLocal, Basic) {
+  // Verify that both started out null.
+  uint* p = tls1;
+  EXPECT_EQ(nullptr, p);
+  p = tls2;
+  EXPECT_EQ(nullptr, p);
+
+  // Set tls1, then verify that only tls1 changed, not tls2.
+  uint i = 123;
+  tls1 = &i;
+
+  p = tls1;
+  EXPECT_EQ(&i, p);
+  p = tls2;
+  EXPECT_EQ(nullptr, p);
+
+  // Check that in another thread, tls1 starts null but can be changed.
+  uint j = 456;
+  bool threadDone = false;
+  Thread([&]() {
+    p = tls1;
+    EXPECT_EQ(nullptr, p);
+    tls1 = &j;
+
+    p = tls1;
+    EXPECT_EQ(&j, p);
+    threadDone = true;
+  });
+  EXPECT_TRUE(threadDone);
+
+  // tls1 didn't change in this thread.
+  p = tls1;
+  EXPECT_EQ(&i, p);
+}
+
+}  // namespace
+}  // namespace kj

c++/src/kj/threadlocal.h

+// Copyright (c) 2014, Jason Choy <jjwchoy@gmail.com>
+// Copyright (c) 2014, Kenton Varda <temporal@gmail.com>
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef KJ_THREADLOCAL_H_
+#define KJ_THREADLOCAL_H_
+// This file declares a macro `KJ_THREADLOCAL_PTR` for declaring thread-local pointer-typed
+// variables.  Use like:
+//     KJ_THREADLOCAL_PTR(MyType) foo = nullptr;
+// This is equivalent to:
+//     thread_local MyType* foo = nullptr;
+// This can only be used at the global scope.
+//
+// AVOID USING THIS.  Use of thread-locals is discouraged because they often have many of the same
+// properties as singletons: http://www.object-oriented-security.org/lets-argue/singletons
+//
+// Also, thread-locals tend to be hostile to event-driven code, which can be particularly
+// surprising when using fibers (all fibers in the same thread will share the same threadlocals,
+// even though they do not share a stack).
+//
+// That said, thread-locals are sometimes needed for runtime logistics in the KJ framework.  For
+// example, the current exception callback and current EventLoop are stored as thread-local
+// pointers.  Since KJ only ever needs to store pointers, not values, we avoid the question of
+// whether these values' destructors need to be run, and we avoid the need for heap allocation.
+
+#include "common.h"
+
+#if !defined(KJ_USE_PTHREAD_THREADLOCAL) && defined(__APPLE__)
+#include "TargetConditionals.h"
+#if TARGET_OS_IPHONE
+// iOS apparently does not support __thread (nor C++11 thread_local).
+#define KJ_USE_PTHREAD_TLS 1
+#endif
+#endif
+
+#if KJ_USE_PTHREAD_TLS
+#include <pthread.h>
+#endif
+
+namespace kj {
+
+#if KJ_USE_PTHREAD_TLS
+// If __thread is unavailable, we'll fall back to pthreads.
+
+#define KJ_THREADLOCAL_PTR(type) \
+  namespace { struct KJ_UNIQUE_NAME(_kj_TlpTag); } \
+  static ::kj::_::ThreadLocalPtr< type, KJ_UNIQUE_NAME(_kj_TlpTag)>
+// Hack:  In order to ensure each thread-local results in a unique template instance, we declare
+//   a one-off dummy type to use as the second type parameter.
+
+namespace _ {  // private
+
+template <typename T, typename>
+class ThreadLocalPtr {
+  // Hacky type to emulate __thread T*.  We need a separate instance of the ThreadLocalPtr template
+  // for every thread-local variable, because we don't want to require a global constructor, and in
+  // order to initialize the TLS on first use we need to use a local static variable (in getKey()).
+  // Each template instance will get a separate such local static variable, fulfilling our need.
+
+public:
+  ThreadLocalPtr() = default;
+  constexpr ThreadLocalPtr(decltype(nullptr)) {}
+  // Allow initialization to nullptr without a global constructor.
+
+  inline ThreadLocalPtr& operator=(T* val) {
+    pthread_setspecific(getKey(), val);
+    return *this;
+  }
+
+  inline operator T*() const {
+    return get();
+  }
+
+  inline T& operator*() const {
+    return *get();
+  }
+
+  inline T* operator->() const {
+    return get();
+  }
+
+private:
+  inline T* get() const {
+    return reinterpret_cast<T*>(pthread_getspecific(getKey()));
+  }
+
+  inline static pthread_key_t getKey() {
+    static pthread_key_t key = createKey();
+    return key;
+  }
+
+  static pthread_key_t createKey() {
+    pthread_key_t key;
+    pthread_key_create(&key, 0);
+    return key;
+  }
+};
+
+}  // namespace _ (private)
+
+#else
+
+#define KJ_THREADLOCAL_PTR(type) static __thread type*
+// For
+
+#endif // KJ_USE_PTHREAD_TLS
+
+}  // namespace kj
+
+#endif  // KJ_THREADLOCAL_H_