[Threading] Fix some problems with the C11 threading code.

These changes are needed to get things building with a C11 threads shim
header on macOS.

rdar://90776105

Author: al45tair

include/swift/Threading/Impl/C11.h

@@ -17,9 +17,12 @@
 #ifndef SWIFT_THREADING_IMPL_C11_H
 #define SWIFT_THREADING_IMPL_C11_H
 
-#include <stdatomic.h>
+#include <atomic>
+#include <cstdint>
 #include <threads.h>
 
+#include "swift/Threading/Errors.h"
+
 namespace swift {
 namespace threading_impl {
 
@@ -58,11 +61,9 @@ inline bool threads_same(thread_id a, thread_id b) {
 using mutex_handle = ::mtx_t;
 
 inline void mutex_init(mutex_handle &handle, bool checked = false) {
-  SWIFT_C11THREADS_CHECK(::mtx_init(&handle), ::mtx_plain);
-}
-inline void mutex_destroy(mutex_handle &handle) {
-  SWIFT_C11THREADS_CHECK(::mtx_destroy(&handle));
+  SWIFT_C11THREADS_CHECK(::mtx_init(&handle, ::mtx_plain));
 }
+inline void mutex_destroy(mutex_handle &handle) { ::mtx_destroy(&handle); }
 
 inline void mutex_lock(mutex_handle &handle) {
   SWIFT_C11THREADS_CHECK(::mtx_lock(&handle));
@@ -83,33 +84,38 @@ inline void mutex_unsafe_unlock(mutex_handle &handle) {
 
 struct lazy_mutex_handle {
   ::mtx_t mutex;
-  ::atomic_int once; // -1 = initialized, 0 = uninitialized, 1 = initializing
+  std::int32_t once; // -1 = initialized, 0 = uninitialized, 1 = initializing
 };
 
 inline constexpr lazy_mutex_handle lazy_mutex_initializer() {
-  return (lazy_mutex_handle){0};
+  return (lazy_mutex_handle){};
 }
 inline void lazy_mutex_init(lazy_mutex_handle &handle) {
   // Sadly, we can't use call_once() for this as it doesn't have a context
-  if (::atomic_load_explicit(&handle.once, ::memory_order_acquire) < 0)
+  if (std::atomic_load_explicit((std::atomic<std::int32_t> *)&handle.once,
+                                std::memory_order_acquire) < 0)
     return;
 
-  if (::atomic_compare_exchange_strong_explicit(&handle.once, &(int){0}, 1,
-                                                ::memory_order_relaxed,
-                                                ::memory_order_relaxed)) {
+  int zero = 0;
+  if (std::atomic_compare_exchange_strong_explicit(
+          (std::atomic<std::int32_t> *)&handle.once, &zero, 1,
+          std::memory_order_relaxed, std::memory_order_relaxed)) {
     SWIFT_C11THREADS_CHECK(::mtx_init(&handle.mutex, ::mtx_plain));
-    ::atomic_store_explicit(&handle.once, -1, ::memory_order_release);
+    std::atomic_store_explicit((std::atomic<std::int32_t> *)&handle.once, -1,
+                               std::memory_order_release);
     return;
   }
 
-  while (::atomic_load_explicit(&handle.once, memory_order_acquire) >= 0) {
+  while (std::atomic_load_explicit((std::atomic<std::int32_t> *)&handle.once,
+                                   std::memory_order_acquire) >= 0) {
     // Just spin; ::mtx_init() is very likely to be fast
   }
 }
 
 inline void lazy_mutex_destroy(lazy_mutex_handle &handle) {
-  if (::atomic_load_explicit(&handle.once, ::memory_order_acquire) < 0)
-    SWIFT_C11THREADS_CHECK(::mtx_destroy(&handle.mutex));
+  if (std::atomic_load_explicit((std::atomic<std::int32_t> *)&handle.once,
+                                std::memory_order_acquire) < 0)
+    ::mtx_destroy(&handle.mutex);
 }
 
 inline void lazy_mutex_lock(lazy_mutex_handle &handle) {
@@ -136,20 +142,24 @@ inline void lazy_mutex_unsafe_unlock(lazy_mutex_handle &handle) {
 
 // .. Once ...................................................................
 
-typedef ::atomic_int once_t;
+typedef std::atomic<std::int64_t> once_t;
 
 void once_slow(once_t &predicate, void (*fn)(void *), void *context);
 
 inline void once_impl(once_t &predicate, void (*fn)(void *), void *context) {
   // Sadly we can't use call_once() for this (no context)
-  if (::atomic_load_explicit(&predicate, ::memory_order_acquire) < 0)
+  if (std::atomic_load_explicit(&predicate, std::memory_order_acquire) < 0)
     return;
 
   once_slow(predicate, fn, context);
 }
 
 // .. Thread local storage ...................................................
 
+// Get rid of this, because it causes clashes with TokenKinds.def
+#undef thread_local
+
+// We *can* use the C++ version though
 #if __cplusplus >= 201103L || __has_feature(cxx_thread_local)
 #define SWIFT_THREAD_LOCAL thread_local
 #endif

include/swift/Threading/ThreadLocalStorage.h

@@ -86,20 +86,18 @@ inline void tls_alloc_once(once_t &token, tls_key &key, tls_dtor dtor) {
 
 // A wrapper class for thread-local storage.
 //
-// - On platforms that report SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL
-//   above, an object of this type is declared with
-//   SWIFT_RUNTIME_ATTRIBUTE_THREAD_LOCAL.  This makes the object
+// - On platforms that define SWIFT_THREAD_LOCAL, an object of this type
+//   is declared with SWIFT_THREAD_LOCAL.  This makes the object
 //   itself thread-local, and no internal support is required.
 //
 //   Note that this includes platforms that don't support threading,
-//   for which SWIFT_RUNTIME_ATTRIBUTE_THREAD_LOCAL is empty;
-//   thread-local declarations then create an ordinary global.
+//   for which SWIFT_THREAD_LOCAL is empty; thread-local declarations
+//   then create an ordinary global.
 //
-// - On platforms that don't report SWIFT_RUNTIME_SUPPORTS_THREAD_LOCAL,
-//   we have to simulate thread-local storage.  Fortunately, all of
-//   these platforms (at least for now) support pthread_getspecific
-//   or similar.
-#if SWIFT_THREAD_LOCAL
+// - On platforms that don't define SWIFT_THREAD_LOCAL, we have to simulate
+//   thread-local storage.  Fortunately, all of these platforms (at least
+//   for now) support pthread_getspecific or similar.
+#ifdef SWIFT_THREAD_LOCAL
 template <class T>
 class ThreadLocal {
   VALIDATE_THREAD_LOCAL_TYPE(T)
@@ -179,7 +177,7 @@ class ThreadLocal {
 /// Because of the fallback path, the default-initialization of the
 /// type must be equivalent to a bitwise zero-initialization, and the
 /// type must be small and trivially copyable and destructible.
-#if SWIFT_THREAD_LOCAL
+#ifdef SWIFT_THREAD_LOCAL
 #define SWIFT_THREAD_LOCAL_TYPE(TYPE, KEY)                                     \
   SWIFT_THREAD_LOCAL swift::ThreadLocal<TYPE>
 #elif SWIFT_THREADING_USE_RESERVED_TLS_KEYS

lib/FrontendTool/CMakeLists.txt

@@ -26,6 +26,7 @@ target_link_libraries(swiftFrontendTool PRIVATE
     swiftSIL
     swiftSILGen
     swiftSILOptimizer
-    swiftTBDGen)
+    swiftTBDGen
+    swiftThreading)
 
 set_swift_llvm_is_available(swiftFrontendTool)

lib/Threading/C11.cpp

@@ -22,12 +22,12 @@
 namespace {
 
 #pragma clang diagnostic push
-#pragma GCC diagnostic ignored "-Wglobal-constructors"
+#pragma clang diagnostic ignored "-Wglobal-constructors"
 
 class C11ThreadingHelper {
 private:
   thrd_t mainThread_;
-  mut_t onceMutex_;
+  mtx_t onceMutex_;
   cnd_t onceCond_;
 
 public:
@@ -64,12 +64,13 @@ bool swift::threading_impl::thread_is_main() {
 
 void swift::threading_impl::once_slow(once_t &predicate, void (*fn)(void *),
                                       void *context) {
-  if (::atomic_compare_exchange_strong_explicit(&predicate, &(int){0}, 1,
-                                                ::memory_order_relaxed,
-                                                ::memory_order_relaxed)) {
+  std::int64_t zero = 0;
+  if (std::atomic_compare_exchange_strong_explicit(&predicate, &zero, 1,
+                                                   std::memory_order_relaxed,
+                                                   std::memory_order_relaxed)) {
     fn(context);
 
-    ::atomic_store_explicit(&predicate, -1, ::memory_order_release);
+    std::atomic_store_explicit(&predicate, -1, std::memory_order_release);
 
     helper.once_lock();
     helper.once_unlock();
@@ -78,7 +79,8 @@ void swift::threading_impl::once_slow(once_t &predicate, void (*fn)(void *),
   }
 
   helper.once_lock();
-  while (::atomic_load_explicit(&predicate, memory_order_acquire) >= 0) {
+  while (std::atomic_load_explicit(&predicate, std::memory_order_acquire) >=
+         0) {
     helper.once_wait();
   }
   helper.once_unlock();

lib/Threading/CMakeLists.txt

@@ -1,8 +1,13 @@
 # If you update this, you also need to update the CMakeLists.txt file in
 # stdlib/public/Threading
 
+# Note that it is *not* an error that Errors.cpp is only listed here.
+# It shouldn't be in stdlib/public/Threading because that is an OBJECT_LIBRARY
+# and things that use that should be defining their own fatal error handler.
+
 add_swift_host_library(swiftThreading STATIC
   C11.cpp
   Linux.cpp
   Pthreads.cpp
-  Win32.cpp)
+  Win32.cpp
+  Errors.cpp)

lib/Threading/Errors.cpp

@@ -0,0 +1,41 @@
+//==--- Errors.cpp - Threading implementation error handling --- -*-C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Provides a fallback definition of swift::threading::fatal().  You may
+// care to provide your own definition elsewhere, to tie the threading code's
+// error handling into the relevant code.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+
+#include "swift/Threading/Errors.h"
+
+namespace swift {
+namespace threading {
+
+SWIFT_ATTRIBUTE_NORETURN
+SWIFT_FORMAT(1, 2)
+void fatal(const char *msg, ...) {
+  std::va_list val;
+
+  va_start(val, msg);
+  std::vfprintf(stderr, msg, val);
+  va_end(val);
+
+  std::abort();
+}
+
+} // namespace threading
+} // namespace swift

stdlib/public/Concurrency/AsyncLet.cpp

@@ -14,14 +14,16 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "swift/ABI/AsyncLet.h"
+#include "swift/Runtime/Concurrency.h"
+
 #include "../CompatibilityOverride/CompatibilityOverride.h"
 #include "Debug.h"
 #include "TaskPrivate.h"
+
+#include "swift/ABI/AsyncLet.h"
 #include "swift/ABI/Metadata.h"
 #include "swift/ABI/Task.h"
 #include "swift/ABI/TaskOptions.h"
-#include "swift/Runtime/Concurrency.h"
 #include "swift/Runtime/Heap.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Threading/Mutex.h"

stdlib/public/Threading/CMakeLists.txt

@@ -7,3 +7,12 @@ add_swift_target_library(swiftThreading OBJECT_LIBRARY
   "${SWIFT_SOURCE_DIR}/lib/Threading/Pthreads.cpp"
   "${SWIFT_SOURCE_DIR}/lib/Threading/Win32.cpp"
   INSTALL_IN_COMPONENT never_install)
+
+# This is only used by the compatibility libraries
+add_swift_target_library(swiftThreadingWithFatal OBJECT_LIBRARY
+  "${SWIFT_SOURCE_DIR}/lib/Threading/C11.cpp"
+  "${SWIFT_SOURCE_DIR}/lib/Threading/Linux.cpp"
+  "${SWIFT_SOURCE_DIR}/lib/Threading/Pthreads.cpp"
+  "${SWIFT_SOURCE_DIR}/lib/Threading/Win32.cpp"
+  "${SWIFT_SOURCE_DIR}/lib/Threading/Errors.cpp"
+  INSTALL_IN_COMPONENT never_install)

stdlib/public/runtime/RuntimeInvocationsTracking.cpp

@@ -15,6 +15,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include <cstdint>
+
 #include "RuntimeInvocationsTracking.h"
 #include "swift/Basic/Lazy.h"
 #include "swift/Runtime/HeapObject.h"
@@ -32,7 +34,7 @@ namespace swift {
 // functions.
 struct RuntimeFunctionCountersState {
 #define FUNCTION_TO_TRACK(RT_FUNCTION)                                         \
-  uint32_t SWIFT_RT_FUNCTION_INVOCATION_COUNTER_NAME(RT_FUNCTION) = 0;
+  std::uint32_t SWIFT_RT_FUNCTION_INVOCATION_COUNTER_NAME(RT_FUNCTION) = 0;
 // Provide one counter per runtime function being tracked.
 #include "RuntimeInvocationsTracking.def"
 };
@@ -73,7 +75,7 @@ static const char *RuntimeFunctionNames[] {
 /// Define an enum where each enumerator corresponds to a runtime function being
 /// tracked. Their order is the same as the order of the counters in the
 /// RuntimeObjectState structure.
-enum RuntimeFunctionNamesIDs : uint32_t {
+enum RuntimeFunctionNamesIDs : std::uint32_t {
 /// Defines names of enum cases for each function being tracked.
 #define FUNCTION_TO_TRACK(RT_FUNCTION) RT_FUNCTION_ID(RT_FUNCTION),
 #include "RuntimeInvocationsTracking.def"
@@ -87,10 +89,10 @@ static RuntimeFunctionCountersUpdateHandler
 /// The offsets of the runtime function counters being tracked inside the
 /// RuntimeObjectState structure. The array is indexed by
 /// the enumerators from RuntimeFunctionNamesIDs.
-static uint16_t RuntimeFunctionCountersOffsets[] = {
+static std::uint16_t RuntimeFunctionCountersOffsets[] = {
 /// Define offset for each function being tracked.
 #define FUNCTION_TO_TRACK(RT_FUNCTION)                                         \
-  (sizeof(uint16_t) * (unsigned)RT_FUNCTION_ID(RT_FUNCTION)),
+  (sizeof(std::uint16_t) * (unsigned)RT_FUNCTION_ID(RT_FUNCTION)),
 #include "RuntimeInvocationsTracking.def"
 };
 
@@ -169,17 +171,17 @@ const char **_swift_getRuntimeFunctionNames() {
 /// Return the offsets of the runtime function counters being tracked.
 /// Their order is the same as the order of the counters in the
 /// RuntimeObjectState structure.
-const uint16_t *_swift_getRuntimeFunctionCountersOffsets() {
+const std::uint16_t *_swift_getRuntimeFunctionCountersOffsets() {
   return RuntimeFunctionCountersOffsets;
 }
 
 /// Return the number of runtime functions being tracked.
-uint64_t _swift_getNumRuntimeFunctionCounters() {
+std::uint64_t _swift_getNumRuntimeFunctionCounters() {
   return ID_LastRuntimeFunctionName;
 }
 
 static void _swift_dumpRuntimeCounters(RuntimeFunctionCountersState *State) {
-  uint32_t tmp;
+  std::uint32_t tmp;
 /// Define how to dump the counter for a given runtime function.
 #define FUNCTION_TO_TRACK(RT_FUNCTION)                                         \
   tmp = State->SWIFT_RT_FUNCTION_INVOCATION_COUNTER_NAME(RT_FUNCTION);         \

stdlib/public/stubs/Stubs.cpp

@@ -558,7 +558,7 @@ __swift_bool _swift_stdlib_getCurrentStackBounds(__swift_uintptr_t *outBegin,
 
 #elif SWIFT_THREADING_C11
   // We don't know any way to do this for C11 threads
-  return false
+  return false;
 
 #elif SWIFT_THREADING_WIN32