Merge pull request swiftlang#36281 from aschwaighofer/wip_new_abi

New Async ABI

Author: aschwaighofer

include/swift/ABI/Task.h

@@ -550,18 +550,40 @@ class YieldingAsyncContext : public AsyncContext {
 class FutureAsyncContext : public AsyncContext {
 public:
   SwiftError **errorResult = nullptr;
-  OpaqueValue *indirectResult;
 
   using AsyncContext::AsyncContext;
 };
 
-/// An asynchronous context within a task that describes a general "Future"
-/// task that was started with a closure context.
-class FutureClosureAsyncContext : public FutureAsyncContext {
+/// This matches the ABI of a closure `() async throws -> ()`
+using AsyncVoidClosureEntryPoint =
+  SWIFT_CC(swiftasync)
+  void (SWIFT_ASYNC_CONTEXT AsyncContext *, SWIFT_CONTEXT HeapObject *);
+
+/// This matches the ABI of a closure `<T>() async throws -> T`
+using AsyncGenericClosureEntryPoint =
+    SWIFT_CC(swiftasync)
+    void(OpaqueValue *,
+         SWIFT_ASYNC_CONTEXT AsyncContext *, SWIFT_CONTEXT HeapObject *);
+
+class AsyncContextPrefix {
 public:
+  // Async closure entry point adhering to compiler calling conv (e.g directly
+  // passing the closure context instead of via the async context)
+  AsyncVoidClosureEntryPoint *__ptrauth_swift_task_resume_function
+      asyncEntryPoint;
   HeapObject *closureContext;
+};
 
-  using FutureAsyncContext::FutureAsyncContext;
+/// Storage that is allocated before the AsyncContext to be used by an adapter
+/// of Swift's async convention and the ResumeTask interface.
+class FutureAsyncContextPrefix {
+public:
+  OpaqueValue *indirectResult;
+  // Async closure entry point adhering to compiler calling conv (e.g directly
+  // passing the closure context instead of via the async context)
+  AsyncGenericClosureEntryPoint *__ptrauth_swift_task_resume_function
+      asyncEntryPoint;
+  HeapObject *closureContext;
 };
 
 } // end namespace swift

include/swift/Runtime/Concurrency.h

@@ -117,8 +117,11 @@ SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 JobPriority
 swift_task_escalate(AsyncTask *task, JobPriority newPriority);
 
+/// This matches the ABI of a closure `<T>(Builtin.NativeObject) async -> T`
 using TaskFutureWaitSignature =
-  AsyncSignature<void(AsyncTask *, OpaqueValue *), /*throws*/ false>;
+    SWIFT_CC(swiftasync)
+    void(OpaqueValue *,
+         SWIFT_ASYNC_CONTEXT AsyncContext *, AsyncTask *, Metadata *);
 
 /// Wait for a non-throwing future task to complete.
 ///
@@ -129,11 +132,13 @@ using TaskFutureWaitSignature =
 ///     -> Success
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
-TaskFutureWaitSignature::FunctionType
-swift_task_future_wait;
+void swift_task_future_wait(OpaqueValue *,
+         SWIFT_ASYNC_CONTEXT AsyncContext *, AsyncTask *, Metadata *);
 
 using TaskFutureWaitThrowingSignature =
-  AsyncSignature<void(AsyncTask *, OpaqueValue *), /*throws*/ true>;
+    SWIFT_CC(swiftasync)
+    void(OpaqueValue *,
+         SWIFT_ASYNC_CONTEXT AsyncContext *, AsyncTask *, Metadata *);
 
 /// Wait for a potentially-throwing future task to complete.
 ///
@@ -144,11 +149,15 @@ using TaskFutureWaitThrowingSignature =
 ///    async throws -> Success
 /// \endcode
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
-TaskFutureWaitThrowingSignature::FunctionType
-swift_task_future_wait_throwing;
+void swift_task_future_wait_throwing(OpaqueValue *,
+                                     SWIFT_ASYNC_CONTEXT AsyncContext *,
+                                     AsyncTask *, Metadata *);
 
 using TaskGroupFutureWaitThrowingSignature =
-  AsyncSignature<void(AsyncTask *, TaskGroup *, Metadata *), /*throws*/ true>;
+SWIFT_CC(swiftasync)
+  void(OpaqueValue *,
+       SWIFT_ASYNC_CONTEXT AsyncContext *, AsyncTask *, TaskGroup *,
+       const Metadata *successType);
 
 /// Wait for a readyQueue of a Channel to become non empty.
 ///
@@ -160,9 +169,11 @@ using TaskGroupFutureWaitThrowingSignature =
 ///     group: UnsafeRawPointer
 /// ) async -> T
 /// \endcode
-SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swiftasync)
-TaskGroupFutureWaitThrowingSignature::FunctionType
-swift_taskGroup_wait_next_throwing;
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swiftasync)
+void swift_taskGroup_wait_next_throwing(
+    OpaqueValue *resultPointer, SWIFT_ASYNC_CONTEXT AsyncContext *rawContext,
+    TaskGroup *group, const Metadata *successType);
 
 /// Create a new `TaskGroup`.
 /// The caller is responsible for retaining and managing the group's lifecycle.

lib/IRGen/Callee.h

@@ -176,10 +176,15 @@ namespace irgen {
         switch (getSpecialKind()) {
         case SpecialKind::TaskFutureWait:
         case SpecialKind::TaskFutureWaitThrowing:
+          // FIXME: I have disabled this optimization, if we bring it back we
+          // need to debug why it currently does not work (call emission
+          // computes an undef return pointer) and change the runtime entries to
+          // remove the extra type parameter.
+          //
           // We suppress generics from these as a code-size optimization
           // because the runtime can recover the success type from the
           // future.
-          return true;
+          return false;
         case SpecialKind::TaskGroupWaitNext:
           return false;
         }

lib/IRGen/EntryPointArgumentEmission.h

@@ -43,6 +43,7 @@ class NativeCCEntryPointArgumentEmission
     : public virtual EntryPointArgumentEmission {
 
 public:
+  virtual void mapAsyncParameters() = 0;
   virtual llvm::Value *getCallerErrorResultArgument() = 0;
   virtual llvm::Value *getContext() = 0;
   virtual Explosion getArgumentExplosion(unsigned index, unsigned size) = 0;