Merge branch 'main' of github.com:apple/swift into tensorflow-stage

* 'main' of github.com:apple/swift:
  Make Float16 available for macOS on Apple Silicon (swiftlang#34821)
  [concurrency] Correctly handle dead-end and unreachable blocks in OptimizeHopToExecutor
  [Concurrency] Remove the C++ runtime test for swift_future_task_wait.
  [Concurrency] Implement Task.Handle.get() in terms of an async runtime call.
  SILGen: Update emitForeignToNativeThunk to handle async methods.

Author: ainu-bot

include/swift/Runtime/Concurrency.h

@@ -110,31 +110,31 @@ swift_task_escalate(AsyncTask *task, JobPriority newPriority);
 
 /// The result of waiting for a task future.
 struct TaskFutureWaitResult {
-  enum Kind : uintptr_t {
-    /// The waiting task has been added to the future's wait queue, and will
-    /// be scheduled once the future has completed.
-    Waiting,
-
-    /// The future succeeded and produced a result value. \c storage points
-    /// at that value.
-    Success,
-
-    /// The future finished by throwing an error. \c storage is that error
-    /// existential.
-    Error,
-  };
-
-  Kind kind;
+  /// Whether the storage represents the error result vs. the successful
+  /// result.
+  bool hadErrorResult;
+
+  /// Storage for the result of the future.
+  ///
+  /// When the future completed normally, this is a pointer to the storage
+  /// of the result value, which lives inside the future task itself.
+  ///
+  /// When the future completed by throwing an error, this is the error
+  /// object itself.
   OpaqueValue *storage;
 };
 
 /// Wait for a future task to complete.
 ///
-/// This can be called from any thread.
+/// This can be called from any thread. Its Swift signature is
 ///
+/// \code
+/// func swift_task_future_wait(on task: Builtin.NativeObject) async
+///     -> TaskFutureWaitResult
+/// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
-TaskFutureWaitResult
-swift_task_future_wait(AsyncTask *task, AsyncTask *waitingTask);
+AsyncFunctionType<TaskFutureWaitResult(AsyncTask *task)>
+swift_task_future_wait;
 
 /// Add a status record to a task.  The record should not be
 /// modified while it is registered with a task.

lib/SILGen/SILGenBridging.cpp

@@ -1662,11 +1662,19 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
       getConstantInfo(getTypeExpansionContext(), foreignDeclRef);
   auto foreignFnTy = foreignCI.SILFnType;
 
-  // Find the foreign error convention and 'self' parameter index.
+  // Find the foreign error/async convention and 'self' parameter index.
+  bool hasError = false;
+  Optional<ForeignAsyncConvention> foreignAsync;
+  if (nativeFnTy->isAsync()) {
+    foreignAsync = fd->getForeignAsyncConvention();
+    assert(foreignAsync && "couldn't find foreign async convention?!");
+  }
   Optional<ForeignErrorConvention> foreignError;
   if (nativeFnTy->hasErrorResult()) {
+    hasError = true;
     foreignError = fd->getForeignErrorConvention();
-    assert(foreignError && "couldn't find foreign error convention!");
+    assert((foreignError || foreignAsync)
+           && "couldn't find foreign error or async convention for foreign error!");
   }
   ImportAsMemberStatus memberStatus = fd->getImportAsMemberStatus();
 
@@ -1707,7 +1715,7 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
 
   // Set up the throw destination if necessary.
   CleanupLocation cleanupLoc(fd);
-  if (foreignError) {
+  if (hasError) {
     prepareRethrowEpilog(cleanupLoc);
   }
 
@@ -1719,14 +1727,20 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
     SmallVector<ManagedValue, 8> args;
     unsigned foreignArgIndex = 0;
 
-    // A helper function to add a function error argument in the
+    // A helper function to add a placeholder for a foreign argument in the
     // appropriate position.
-    auto maybeAddForeignErrorArg = [&] {
-      if (foreignError &&
-          foreignArgIndex == foreignError->getErrorParameterIndex()) {
+    auto maybeAddForeignArg = [&]() -> bool {
+      if ((foreignError
+           && foreignArgIndex == foreignError->getErrorParameterIndex())
+          || (foreignAsync
+              && foreignArgIndex == foreignAsync->completionHandlerParamIndex()))
+      {
         args.push_back(ManagedValue());
         ++foreignArgIndex;
+        return true;
       }
+      
+      return false;
     };
 
     {
@@ -1768,7 +1782,7 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
           llvm_unreachable("unsupported convention");
         }
 
-        maybeAddForeignErrorArg();
+        while (maybeAddForeignArg());
 
         bool isSelf = (hasSelfParam && nativeParamIndex == params.size() - 1);
 
@@ -1825,7 +1839,7 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
       }
     }
 
-    maybeAddForeignErrorArg();
+    while (maybeAddForeignArg());
 
     // Call the original.
     auto subs = getForwardingSubstitutionMap();
@@ -1846,7 +1860,7 @@ void SILGenFunction::emitForeignToNativeThunk(SILDeclRef thunk) {
                                    bridgedFormalResultType),
         nativeFormalResultType,
         foreignError,
-        {}, // TODO foreignAsync
+        foreignAsync,
         ImportAsMemberStatus());
 
     auto init = indirectResult

lib/SILOptimizer/Mandatory/OptimizeHopToExecutor.cpp

@@ -144,40 +144,44 @@ void OptimizeHopToExecutor::allocateBlockStates() {
 /// Solve the dataflow in forward direction.
 void OptimizeHopToExecutor::solveDataflowForward() {
   bool changed = false;
+  bool firstRound = true;
   do {
     changed = false;
     for (BlockState &state : blockStates) {
       int newEntry = state.entry;
       for (SILBasicBlock *pred : state.block->getPredecessorBlocks()) {
         newEntry = BlockState::merge(newEntry, block2State[pred]->exit);
       }
-      if (newEntry != state.entry || state.exit == BlockState::NotSet) {
+      if (newEntry != state.entry || firstRound) {
         changed = true;
         state.entry = newEntry;
         if (state.intra == BlockState::NotSet)
           state.exit = state.entry;
       }
     }
+    firstRound = false;
   } while (changed);
 }
 
 /// Solve the dataflow in backward direction.
 void OptimizeHopToExecutor::solveDataflowBackward() {
   bool changed = false;
+  bool firstRound = true;
   do {
     changed = false;
     for (BlockState &state : llvm::reverse(blockStates)) {
       int newExit = state.exit;
       for (SILBasicBlock *succ : state.block->getSuccessorBlocks()) {
         newExit = BlockState::merge(newExit, block2State[succ]->entry);
       }
-      if (newExit != state.exit || state.entry == BlockState::NotSet) {
+      if (newExit != state.exit || firstRound) {
         changed = true;
         state.exit = newExit;
         if (state.intra == BlockState::NotSet)
           state.entry = state.exit;
       }
     }
+    firstRound = false;
   } while (changed);
 }
 
@@ -255,7 +259,7 @@ bool OptimizeHopToExecutor::removeDeadHopToExecutors() {
   // might require a dedicated executor, don't remove a preceeding
   // hop_to_executor instruction.
   for (BlockState &state : blockStates) {
-    state.exit = (state.block->getTerminator()->isFunctionExiting() ?
+    state.exit = (state.block->getSuccessors().empty() ?
                     BlockState::NoExecutorNeeded : BlockState::NotSet);
     state.intra = BlockState::NotSet;
     for (SILInstruction &inst : llvm::reverse(*state.block)) {

stdlib/public/Concurrency/Task.cpp

@@ -73,6 +73,56 @@ FutureFragment::Status AsyncTask::waitFuture(AsyncTask *waitingTask) {
   }
 }
 
+
+namespace {
+
+/// An asynchronous context within a task that describes a general "Future".
+/// task.
+///
+/// This type matches the ABI of a function `<T> () async throws -> T`, which
+/// is the type used by `Task.runDetached` and `Task.group.add` to create
+/// futures.
+class TaskFutureWaitAsyncContext : public AsyncContext {
+public:
+  // Error result is always present.
+  SwiftError *errorResult = nullptr;
+
+  // No indirect results.
+
+  TaskFutureWaitResult result;
+
+  // FIXME: Currently, this is always here, but it isn't technically
+  // necessary.
+  void* Self;
+
+  // Arguments.
+  AsyncTask *task;
+
+  using AsyncContext::AsyncContext;
+};
+
+}
+
+/// Run the given task, privoding it with the result of the future.
+static void runTaskWithFutureResult(
+    AsyncTask *waitingTask, ExecutorRef executor,
+    FutureFragment *futureFragment, bool hadErrorResult) {
+  auto waitingTaskContext =
+      static_cast<TaskFutureWaitAsyncContext *>(waitingTask->ResumeContext);
+
+  waitingTaskContext->result.hadErrorResult = hadErrorResult;
+  if (hadErrorResult) {
+    waitingTaskContext->result.storage =
+        reinterpret_cast<OpaqueValue *>(futureFragment->getError());
+  } else {
+    waitingTaskContext->result.storage = futureFragment->getStoragePtr();
+  }
+
+  // TODO: schedule this task on the executor rather than running it
+  // directly.
+  waitingTask->run(executor);
+}
+
 void AsyncTask::completeFuture(AsyncContext *context, ExecutorRef executor) {
   using Status = FutureFragment::Status;
   using WaitQueueItem = FutureFragment::WaitQueueItem;
@@ -103,9 +153,8 @@ void AsyncTask::completeFuture(AsyncContext *context, ExecutorRef executor) {
     // Find the next waiting task.
     auto nextWaitingTask = waitingTask->getNextWaitingTask();
 
-    // TODO: schedule this task on the executor rather than running it
-    // directly.
-    waitingTask->run(executor);
+    // Run the task.
+    runTaskWithFutureResult(waitingTask, executor, fragment, hadErrorResult);
 
     // Move to the next task.
     waitingTask = nextWaitingTask;
@@ -264,21 +313,37 @@ AsyncTaskAndContext swift::swift_task_create_future_f(
   return {task, initialContext};
 }
 
-TaskFutureWaitResult
-swift::swift_task_future_wait(AsyncTask *task, AsyncTask *waitingTask) {
+void swift::swift_task_future_wait(
+    AsyncTask *waitingTask, ExecutorRef executor,
+    AsyncContext *rawContext) {
+  // Suspend the waiting task.
+  waitingTask->ResumeTask = rawContext->ResumeParent;
+  waitingTask->ResumeContext = rawContext;
+
+  // Wait on the future.
+  auto context = static_cast<TaskFutureWaitAsyncContext *>(rawContext);
+  auto task = context->task;
   assert(task->isFuture());
   switch (task->waitFuture(waitingTask)) {
   case FutureFragment::Status::Executing:
-    return TaskFutureWaitResult{TaskFutureWaitResult::Waiting, nullptr};
+    // The waiting task has been queued on the future.
+    return;
 
   case FutureFragment::Status::Success:
-    return TaskFutureWaitResult{
-        TaskFutureWaitResult::Success, task->futureFragment()->getStoragePtr()};
-
-   case FutureFragment::Status::Error:
-      return TaskFutureWaitResult{
-          TaskFutureWaitResult::Error,
-          reinterpret_cast<OpaqueValue *>(task->futureFragment()->getError())};
+    // Run the task with a successful result.
+    // FIXME: Want to guarantee a tail call here
+    runTaskWithFutureResult(
+        waitingTask, executor, task->futureFragment(),
+        /*hadErrorResult=*/false);
+    return;
+
+ case FutureFragment::Status::Error:
+    // Run the task with an error result.
+    // FIXME: Want to guarantee a tail call here
+    runTaskWithFutureResult(
+        waitingTask, executor, task->futureFragment(),
+        /*hadErrorResult=*/true);
+    return;
   }
 }