Conditionally start using llvm::CallingConv::SwiftTail for async functions

This is conditional on UseAsyncLowering and in the future should also be
conditional on `clangTargetInfo.isSwiftAsyncCCSupported()` once that
support is merged.

Update tests to work either with swiftcc or swifttailcc.

Author: aschwaighofer

include/swift/Runtime/RuntimeFunctions.def

@@ -1527,7 +1527,7 @@ FUNCTION(TaskCreateFutureFunc,
 //                        ExecutorRef currentExecutor,
 //                        ExecutorRef newExecutor);
 FUNCTION(TaskSwitchFunc,
-         swift_task_switch, SwiftCC,
+         swift_task_switch, SwiftAsyncCC,
          ConcurrencyAvailability,
          RETURNS(VoidTy),
          ARGS(SwiftTaskPtrTy, SwiftExecutorPtrTy, SwiftExecutorPtrTy),

lib/IRGen/GenCall.cpp

@@ -462,7 +462,8 @@ static llvm::CallingConv::ID getFreestandingConvention(IRGenModule &IGM) {
 /// Expand the requirements of the given abstract calling convention
 /// into a "physical" calling convention.
 llvm::CallingConv::ID irgen::expandCallingConv(IRGenModule &IGM,
-                                    SILFunctionTypeRepresentation convention) {
+                                    SILFunctionTypeRepresentation convention,
+                                    bool isAsync) {
   switch (convention) {
   case SILFunctionTypeRepresentation::CFunctionPointer:
   case SILFunctionTypeRepresentation::ObjCMethod:
@@ -474,6 +475,8 @@ llvm::CallingConv::ID irgen::expandCallingConv(IRGenModule &IGM,
   case SILFunctionTypeRepresentation::Closure:
   case SILFunctionTypeRepresentation::Thin:
   case SILFunctionTypeRepresentation::Thick:
+    if (isAsync)
+      return IGM.SwiftAsyncCC;
     return getFreestandingConvention(IGM);
   }
   llvm_unreachable("bad calling convention!");
@@ -1849,7 +1852,8 @@ Signature SignatureExpansion::getSignature() {
            (FnType->getLanguage() == SILFunctionLanguage::C) &&
          "C function type without C function info");
 
-  auto callingConv = expandCallingConv(IGM, FnType->getRepresentation());
+  auto callingConv =
+      expandCallingConv(IGM, FnType->getRepresentation(), FnType->isAsync());
 
   Signature result;
   result.Type = llvmType;
@@ -4808,7 +4812,7 @@ IRGenFunction::getFunctionPointerForResumeIntrinsic(llvm::Value *resume) {
       IGM.VoidTy, {IGM.Int8PtrTy, IGM.Int8PtrTy, IGM.Int8PtrTy},
       false /*vaargs*/);
   auto signature =
-      Signature(fnTy, IGM.constructInitialAttributes(), IGM.SwiftCC);
+      Signature(fnTy, IGM.constructInitialAttributes(), IGM.SwiftAsyncCC);
   auto fnPtr = FunctionPointer(
       FunctionPointer::KindTy::Function,
       Builder.CreateBitOrPointerCast(resume, fnTy->getPointerTo()),

lib/IRGen/GenCall.h

@@ -316,7 +316,8 @@ namespace irgen {
       std::pair<bool, bool> values = {true, true},
       Size initialContextSize = Size(0));
   llvm::CallingConv::ID expandCallingConv(IRGenModule &IGM,
-                                     SILFunctionTypeRepresentation convention);
+                                     SILFunctionTypeRepresentation convention,
+                                     bool isAsync);
 
   Signature emitCastOfFunctionPointer(IRGenFunction &IGF, llvm::Value *&fnPtr,
                                       CanSILFunctionType fnType);

lib/IRGen/GenFunc.cpp

@@ -2582,7 +2582,7 @@ llvm::Function *IRGenFunction::createAsyncSuspendFn() {
       IGM.getTaskSwitchFuncFn(),
       { task, executor, targetExecutor });
   suspendCall->setDoesNotThrow();
-  suspendCall->setCallingConv(IGM.SwiftCC);
+  suspendCall->setCallingConv(IGM.SwiftAsyncCC);
   suspendCall->setTailCall();
   Builder.CreateRetVoid();
   return suspendFn;

lib/IRGen/GenObjC.cpp

@@ -710,8 +710,8 @@ static llvm::Function *emitObjCPartialApplicationForwarder(IRGenModule &IGM,
     llvm::Function::Create(fwdTy, llvm::Function::InternalLinkage,
                            MANGLE_AS_STRING(OBJC_PARTIAL_APPLY_THUNK_SYM),
                            &IGM.Module);
-  fwd->setCallingConv(
-      expandCallingConv(IGM, SILFunctionTypeRepresentation::Thick));
+  fwd->setCallingConv(expandCallingConv(
+      IGM, SILFunctionTypeRepresentation::Thick, false/*isAsync*/));
 
   fwd->setAttributes(attrs);
   // Merge initial attributes with attrs.

lib/IRGen/IRGenModule.cpp

@@ -547,6 +547,9 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   // TODO: use "tinycc" on platforms that support it
   DefaultCC = SWIFT_DEFAULT_LLVM_CC;
   SwiftCC = llvm::CallingConv::Swift;
+  // TODO: Once clang support is merged this should also use
+  //  clangASTContext.getTargetInfo().isSwiftAsyncCCSupported()
+  SwiftAsyncCC = opts.UseAsyncLowering ? llvm::CallingConv::SwiftTail : SwiftCC;
 
   if (opts.DebugInfoLevel > IRGenDebugInfoLevel::None)
     DebugInfo = IRGenDebugInfo::createIRGenDebugInfo(IRGen.Opts, *CI, *this,

lib/IRGen/IRGenModule.h

@@ -753,6 +753,7 @@ class IRGenModule {
   llvm::CallingConv::ID C_CC;          /// standard C calling convention
   llvm::CallingConv::ID DefaultCC;     /// default calling convention
   llvm::CallingConv::ID SwiftCC;       /// swift calling convention
+  llvm::CallingConv::ID SwiftAsyncCC;  /// swift calling convention for async
 
   Signature getAssociatedTypeWitnessTableAccessFunctionSignature();
 

stdlib/public/Concurrency/Actor.cpp

@@ -1328,6 +1328,7 @@ static void runOnAssumedThread(AsyncTask *task, ExecutorRef newExecutor,
     actor->giveUpThread(runner);
 }
 
+SWIFT_CC(swiftasync)
 void swift::swift_task_switch(AsyncTask *task, ExecutorRef currentExecutor,
                               ExecutorRef newExecutor) {
   assert(task && "no task provided");

stdlib/public/Concurrency/Task.cpp

@@ -317,6 +317,7 @@ AsyncTaskAndContext swift::swift_task_create_future_f(
   return {task, initialContext};
 }
 
+SWIFT_CC(swiftasync)
 void swift::swift_task_future_wait(
     AsyncTask *waitingTask, ExecutorRef executor,
     SWIFT_ASYNC_CONTEXT AsyncContext *rawContext) {

stdlib/public/Concurrency/TaskGroup.cpp

@@ -153,7 +153,7 @@ void AsyncTask::groupOffer(AsyncTask *completedTask, AsyncContext *context,
 
 // =============================================================================
 // ==== group.next() implementation (wait_next and groupPoll) ------------------
-
+SWIFT_CC(swiftasync)
 void swift::swift_task_group_wait_next(
     AsyncTask *waitingTask,
     ExecutorRef executor,