Backdeploy task_wait_future fix to Swift 5.6 (#61254)

* Backdeploy swift_task_future_wait

This patch adds the implementation for `swift_task_future_wait`
entrypoint to the backdeploy library.

This involves pulling in `AsyncTask::waitFuture`, which relies on a fair
bit.

Please note, this pulls in the `StaticMutex` implementation from Swift
5.6. There are some challenges here. The concurrency version of the
`StaticMutex` involves a fairly nasty set of ODR violations in the
normal setup. See `public/Concurrency/Mutex.cpp`, which includes the
Mutex implementations cpp files directly, while defining a single macro
to replace the implementation of swift::fatalError with
swift_concurrency_fatalError. We only need the concurrency mutex (at
least for now), so I have hard-coded the `swift_concurrency_fatalError`
version into this library. If we should need the other implementation,
we are forced to include ODR-related undefined behavior.

We need symbols from C++, so I've added an implicit linker flag whenever
the static library is used, namely, it passes `-lc++` to the linker.
Since we only backdeploy on Apple platforms, this should be fine.

Some of the platform runtimes we need to backdeploy to have the
enter/exitThreadLocalContext functions defined, while others don't. We
define our own backdeploy56 shim function that dlsym's the function
pointer for these symbols if we have exclusivity checking available.
Otherwise, it doesn't do anything. If concurrency exclusivity checking
is available, we'll use it, otherwise we wont'.

The same dlsym check is done for `swift_task_escalate`. Not all
platforms we need to backdeploy to have a concurrency runtime. The
symbols that do need to use pieces of the concurrency runtime should not
be getting hit when deploying to systems that don't have concurrency. In
the event that you've gotten around the language blocking you from
calling these symbols and you've managed to call concurrency pieces
without using concurrency, we'll abort because something is seriously
wrong.

* Backdeploy swift_task_future_wait_throwing

Drop the remaining pieces in for adding
`swift_task_future_wait_throwing`.

* Apply task_wait_future fix

Actually apply the fix from ef80a31.

This deviates slightly from the original patch.

AsyncTask::PrivateStorage::_Status() does not exist in the Swift 5.6
library. Instead I am using `AsyncTask::PrivateStorage::Status`.

* Workaround missing compiler-rt linking

Working around the missing link against compiler-rt in these test.
They are a bit brittle as if anything in them uses compiler-rt, they
will start failing. The backdeploy 5.6 library uses some symbols from
compiler-rt, thus causes them to fail to link.

Disabling the runtime compatibility version checking to avoid these
symbols. This should be fine for the MicroStdlib test, but we should fix
'%target-ld' to handle this better in the future.
rdar://100868842

Author: etcwilde

include/swift/Runtime/Exclusivity.h

@@ -72,6 +72,18 @@ void swift_dumpTrackedAccesses();
 
 #endif
 
+#ifdef SWIFT_COMPATIBILITY56
+/// Backdeploy56 shim calls swift_task_enterThreadLocalContext if it is
+/// available in the underlying runtime, otherwise does nothing
+SWIFT_RUNTIME_EXPORT
+void swift_task_enterThreadLocalContextBackdeploy56(char *state);
+
+/// Backdeploy56 shim calls swift_task_exitThreadLocalContext if it is available
+/// in the underlying runtime, otherwise does nothing
+SWIFT_RUNTIME_EXPORT
+void swift_task_exitThreadLocalContextBackdeploy56(char *state);
+#else
+
 // When building the concurrency library for back deployment, we rename these
 // symbols uniformly so they don't conflict with the real concurrency library.
 #ifdef SWIFT_CONCURRENCY_BACK_DEPLOYMENT
@@ -103,6 +115,8 @@ void swift_task_enterThreadLocalContext(char *state);
 SWIFT_RUNTIME_EXPORT
 void swift_task_exitThreadLocalContext(char *state);
 
+#endif
+
 } // end namespace swift
 
 #endif

stdlib/toolchain/Compatibility56/CMakeLists.txt

@@ -2,16 +2,23 @@ set(library_name "swiftCompatibility56")
 
 include_directories("include/" "${SWIFT_STDLIB_SOURCE_DIR}")
 
+add_compile_definitions(SWIFT_COMPATIBILITY56)
 add_swift_target_library("${library_name}" STATIC
   Overrides.cpp
   Concurrency/Task.cpp
+  Concurrency/TaskLocal.cpp
+  Concurrency/TaskStatus.cpp
   Concurrency/Error.cpp
   Concurrency/Actor.cpp
   Concurrency/AsyncLet.cpp
+  Concurrency/ThreadSanitizer.cpp
+  Concurrency/TaskAlloc.cpp
+  Concurrency/MutexPThread.cpp
+  Runtime/Exclusivity.cpp
 
   TARGET_SDKS ${SWIFT_DARWIN_PLATFORMS}
 
-  C_COMPILE_FLAGS ${CXX_COMPILE_FLAGS}
+  C_COMPILE_FLAGS ${CXX_COMPILE_FLAGS} "-D__STDC_WANT_LIB_EXT1__=1"
   LINK_FLAGS ${CXX_LINK_FLAGS}
   INCORPORATE_OBJECT_LIBRARIES swiftCompatibilityThreading
   SWIFT_COMPILE_FLAGS ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}

stdlib/toolchain/Compatibility56/Concurrency/Actor.cpp

@@ -1,13 +1,12 @@
 #include "Runtime/Concurrency.h"
 #include "Concurrency/Actor.h"
 #include "Concurrency/Task.h"
+#include "Concurrency/TaskPrivate.h"
+#include "Concurrency/VoucherSupport.h"
 
 #include "swift/Runtime/Atomic.h"
 #include "swift/Runtime/Casting.h"
-#include "Runtime/Threading/Mutex.h"
-#include "Runtime/Threading/Once.h"
 #include "Runtime/Threading/ThreadLocal.h"
-#include "Runtime/Threading/ThreadLocalStorage.h"
 
 #include <atomic>
 #include <new>
@@ -26,6 +25,84 @@ template <class T> struct Pointer {
   T *operator->() const { return Value; }
 };
 
+/// A class which encapsulates the information we track about
+/// the current thread and active executor.
+class ExecutorTrackingInfo {
+  /// A thread-local variable pointing to the active tracking
+  /// information about the current thread, if any.
+  ///
+  /// TODO: this is obviously runtime-internal and therefore not
+  /// reasonable to make ABI. We might want to also provide a way
+  /// for generated code to efficiently query the identity of the
+  /// current executor, in order to do a cheap comparison to avoid
+  /// doing all the work to suspend the task when we're already on
+  /// the right executor. It would make sense for that to be a
+  /// separate thread-local variable (or whatever is most efficient
+  /// on the target platform).
+  static SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(
+      Pointer<ExecutorTrackingInfo>, ActiveInfoInThread,
+      SWIFT_CONCURRENCY_EXECUTOR_TRACKING_INFO_KEY);
+
+  /// The active executor.
+  ExecutorRef ActiveExecutor = ExecutorRef::generic();
+
+  /// Whether this context allows switching.  Some contexts do not;
+  /// for example, we do not allow switching from swift_job_run
+  /// unless the passed-in executor is generic.
+  bool AllowsSwitching = true;
+
+  VoucherManager voucherManager;
+
+  /// The tracking info that was active when this one was entered.
+  ExecutorTrackingInfo *SavedInfo;
+
+public:
+  ExecutorTrackingInfo() = default;
+
+  ExecutorTrackingInfo(const ExecutorTrackingInfo &) = delete;
+  ExecutorTrackingInfo &operator=(const ExecutorTrackingInfo &) = delete;
+
+  /// Unconditionally initialize a fresh tracking state on the
+  /// current state, shadowing any previous tracking state.
+  /// leave() must be called beforet the object goes out of scope.
+  void enterAndShadow(ExecutorRef currentExecutor) {
+    ActiveExecutor = currentExecutor;
+    SavedInfo = ActiveInfoInThread.get();
+    ActiveInfoInThread.set(this);
+  }
+
+  void swapToJob(Job *job) { voucherManager.swapToJob(job); }
+
+  void restoreVoucher(AsyncTask *task) { voucherManager.restoreVoucher(task); }
+
+  ExecutorRef getActiveExecutor() const {
+    return ActiveExecutor;
+  }
+
+  void setActiveExecutor(ExecutorRef newExecutor) {
+    ActiveExecutor = newExecutor;
+  }
+
+
+  bool allowsSwitching() const {
+    return AllowsSwitching;
+  }
+
+  /// Disallow switching in this tracking context.  This should only
+  /// be set on a new tracking info, before any jobs are run in it.
+  void disallowSwitching() {
+    AllowsSwitching = false;
+  }
+
+  static ExecutorTrackingInfo *current() {
+    return ActiveInfoInThread.get();
+  }
+
+  void leave() {
+    voucherManager.leave();
+    ActiveInfoInThread.set(SavedInfo);
+  }
+};
 
 class ActiveTask {
   /// A thread-local variable pointing to the active tracking
@@ -44,5 +121,28 @@ SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(
   ActiveTask::Value,
   SWIFT_CONCURRENCY_TASK_KEY);
 
+SWIFT_RUNTIME_DECLARE_THREAD_LOCAL(
+  Pointer<ExecutorTrackingInfo>,
+  ExecutorTrackingInfo::ActiveInfoInThread,
+  SWIFT_CONCURRENCY_EXECUTOR_TRACKING_INFO_KEY);
 
 } // namespace
+
+SWIFT_CC(swift)
+AsyncTask *swift::swift_task_getCurrent() {
+  return ActiveTask::get();
+}
+
+AsyncTask *swift::_swift_task_clearCurrent() {
+  auto task = ActiveTask::get();
+  ActiveTask::set(nullptr);
+  return task;
+}
+
+void swift::adoptTaskVoucher(AsyncTask *task) {
+  ExecutorTrackingInfo::current()->swapToJob(task);
+}
+
+void swift::restoreTaskVoucher(AsyncTask *task) {
+  ExecutorTrackingInfo::current()->restoreVoucher(task);
+}

stdlib/toolchain/Compatibility56/Concurrency/MutexPThread.cpp

@@ -0,0 +1,185 @@
+//===--- MutexPThread.cpp - Supports Mutex.h using PThreads ---------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Mutex, ConditionVariable, Read/Write lock, and Scoped lock implementations
+// using PThreads.
+//
+//===----------------------------------------------------------------------===//
+
+#if __has_include(<unistd.h>)
+#include <unistd.h>
+#endif
+
+#if defined(_POSIX_THREADS) && !defined(SWIFT_STDLIB_SINGLE_THREADED_RUNTIME)
+
+// Notes: swift::fatalError is not shared between libswiftCore and libswift_Concurrency
+// and libswift_Concurrency uses swift_Concurrency_fatalError instead.
+/* #ifndef SWIFT_FATAL_ERROR */
+/* #define SWIFT_FATAL_ERROR swift::fatalError */
+/* #endif */
+
+// This is the concurrency Mutex implementation. We're forcing the concurrency
+// fatalError here.
+#include "Concurrency/Error.h"
+#define SWIFT_FATAL_ERROR swift_Concurrency_fatalError
+
+#include "Concurrency/Threading/Mutex.h"
+
+#include "swift/Runtime/Debug.h"
+#include <errno.h>
+#include <stdlib.h>
+
+using namespace swift;
+
+#define reportError(PThreadFunction)                                           \
+  do {                                                                         \
+    int errorcode = PThreadFunction;                                           \
+    if (errorcode != 0) {                                                      \
+      SWIFT_FATAL_ERROR(/* flags = */ 0, "'%s' failed with error '%s'(%d)\n",  \
+                        #PThreadFunction, errorName(errorcode), errorcode);    \
+    }                                                                          \
+  } while (false)
+
+#define returnTrueOrReportError(PThreadFunction, returnFalseOnEBUSY)           \
+  do {                                                                         \
+    int errorcode = PThreadFunction;                                           \
+    if (errorcode == 0)                                                        \
+      return true;                                                             \
+    if (returnFalseOnEBUSY && errorcode == EBUSY)                              \
+      return false;                                                            \
+    SWIFT_FATAL_ERROR(/* flags = */ 0, "'%s' failed with error '%s'(%d)\n",    \
+                      #PThreadFunction, errorName(errorcode), errorcode);      \
+  } while (false)
+
+static const char *errorName(int errorcode) {
+  switch (errorcode) {
+  case EINVAL:
+    return "EINVAL";
+  case EPERM:
+    return "EPERM";
+  case EDEADLK:
+    return "EDEADLK";
+  case ENOMEM:
+    return "ENOMEM";
+  case EAGAIN:
+    return "EAGAIN";
+  case EBUSY:
+    return "EBUSY";
+  default:
+    return "<unknown>";
+  }
+}
+
+void ConditionPlatformHelper::init(pthread_cond_t &condition) {
+  reportError(pthread_cond_init(&condition, nullptr));
+}
+
+void ConditionPlatformHelper::destroy(pthread_cond_t &condition) {
+  reportError(pthread_cond_destroy(&condition));
+}
+
+void ConditionPlatformHelper::notifyOne(pthread_cond_t &condition) {
+  reportError(pthread_cond_signal(&condition));
+}
+
+void ConditionPlatformHelper::notifyAll(pthread_cond_t &condition) {
+  reportError(pthread_cond_broadcast(&condition));
+}
+
+void ConditionPlatformHelper::wait(pthread_cond_t &condition,
+                                   pthread_mutex_t &mutex) {
+  reportError(pthread_cond_wait(&condition, &mutex));
+}
+
+void MutexPlatformHelper::init(pthread_mutex_t &mutex, bool checked) {
+  pthread_mutexattr_t attr;
+  int kind = (checked ? PTHREAD_MUTEX_ERRORCHECK : PTHREAD_MUTEX_NORMAL);
+  reportError(pthread_mutexattr_init(&attr));
+  reportError(pthread_mutexattr_settype(&attr, kind));
+  reportError(pthread_mutex_init(&mutex, &attr));
+  reportError(pthread_mutexattr_destroy(&attr));
+}
+
+void MutexPlatformHelper::destroy(pthread_mutex_t &mutex) {
+  reportError(pthread_mutex_destroy(&mutex));
+}
+
+void MutexPlatformHelper::lock(pthread_mutex_t &mutex) {
+  reportError(pthread_mutex_lock(&mutex));
+}
+
+void MutexPlatformHelper::unlock(pthread_mutex_t &mutex) {
+  reportError(pthread_mutex_unlock(&mutex));
+}
+
+bool MutexPlatformHelper::try_lock(pthread_mutex_t &mutex) {
+  returnTrueOrReportError(pthread_mutex_trylock(&mutex),
+                          /* returnFalseOnEBUSY = */ true);
+}
+
+#if HAS_OS_UNFAIR_LOCK
+
+void MutexPlatformHelper::init(os_unfair_lock &lock, bool checked) {
+  (void)checked; // Unfair locks are always checked.
+  lock = OS_UNFAIR_LOCK_INIT;
+}
+
+void MutexPlatformHelper::destroy(os_unfair_lock &lock) {}
+
+void MutexPlatformHelper::lock(os_unfair_lock &lock) {
+  os_unfair_lock_lock(&lock);
+}
+
+void MutexPlatformHelper::unlock(os_unfair_lock &lock) {
+  os_unfair_lock_unlock(&lock);
+}
+
+bool MutexPlatformHelper::try_lock(os_unfair_lock &lock) {
+  return os_unfair_lock_trylock(&lock);
+}
+
+#endif
+
+void ReadWriteLockPlatformHelper::init(pthread_rwlock_t &rwlock) {
+  reportError(pthread_rwlock_init(&rwlock, nullptr));
+}
+
+void ReadWriteLockPlatformHelper::destroy(pthread_rwlock_t &rwlock) {
+  reportError(pthread_rwlock_destroy(&rwlock));
+}
+
+void ReadWriteLockPlatformHelper::readLock(pthread_rwlock_t &rwlock) {
+  reportError(pthread_rwlock_rdlock(&rwlock));
+}
+
+bool ReadWriteLockPlatformHelper::try_readLock(pthread_rwlock_t &rwlock) {
+  returnTrueOrReportError(pthread_rwlock_tryrdlock(&rwlock),
+                          /* returnFalseOnEBUSY = */ true);
+}
+
+void ReadWriteLockPlatformHelper::writeLock(pthread_rwlock_t &rwlock) {
+  reportError(pthread_rwlock_wrlock(&rwlock));
+}
+
+bool ReadWriteLockPlatformHelper::try_writeLock(pthread_rwlock_t &rwlock) {
+  returnTrueOrReportError(pthread_rwlock_trywrlock(&rwlock),
+                          /* returnFalseOnEBUSY = */ true);
+}
+
+void ReadWriteLockPlatformHelper::readUnlock(pthread_rwlock_t &rwlock) {
+  reportError(pthread_rwlock_unlock(&rwlock));
+}
+
+void ReadWriteLockPlatformHelper::writeUnlock(pthread_rwlock_t &rwlock) {
+  reportError(pthread_rwlock_unlock(&rwlock));
+}
+#endif