Merge pull request #34746 from aschwaighofer/reinstate_task_allocator_size_alignment_requirement

Reinstate task allocator size alignment requirement

Author: aschwaighofer

lib/IRGen/GenOpaque.cpp

@@ -545,6 +545,9 @@ StackAddress IRGenFunction::emitDynamicAlloca(llvm::Type *eltTy,
     } else {
       byteCount = Builder.CreateMul(arraySize, IGM.getSize(Size(eltSize)));
     }
+    // The task allocator wants size increments in the mulitple of
+    // MaximumAlignment.
+    byteCount = alignUpToMaximumAlignment(IGM.SizeTy, byteCount);
     auto address = emitTaskAlloc(byteCount, align);
     return {address, address.getAddress()};
   // In coroutines, call llvm.coro.alloca.alloc.

lib/IRGen/IRGenFunction.cpp

@@ -14,7 +14,7 @@
 //  performs IR generation for function bodies.
 //
 //===----------------------------------------------------------------------===//
-
+#include "swift/ABI/MetadataValues.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/IRGen/Linking.h"
@@ -507,3 +507,9 @@ void IRGenFunction::emitTaskDealloc(Address address) {
   call->setDoesNotThrow();
   call->setCallingConv(IGM.SwiftCC);
 }
+
+llvm::Value *IRGenFunction::alignUpToMaximumAlignment(llvm::Type *sizeTy, llvm::Value *val) {
+  auto *alignMask = llvm::ConstantInt::get(sizeTy, MaximumAlignment - 1);
+  auto *invertedMask = Builder.CreateNot(alignMask);
+  return Builder.CreateAnd(Builder.CreateAdd(val, alignMask), invertedMask);
+}

lib/IRGen/IRGenFunction.h

@@ -460,6 +460,8 @@ class IRGenFunction {
                         Alignment alignment);
   void emitTaskDealloc(Address address);
 
+  llvm::Value *alignUpToMaximumAlignment(llvm::Type *sizeTy, llvm::Value *val);
+
   //--- Expression emission
   //------------------------------------------------------
 public:

stdlib/public/Concurrency/Task.cpp

@@ -213,10 +213,7 @@ AsyncTaskAndContext swift::swift_task_create_future_f(
   // This means that we never get rid of this allocation.
   size_t amountToAllocate = headerSize + initialContextSize;
 
-  // TODO: if this is necessary we need to teach LLVM lowering to request async
-  // context sizes that are mulitple of that maximum alignment.
-  // For now disable this assert.
-  // assert(amountToAllocate % MaximumAlignment == 0);
+  assert(amountToAllocate % MaximumAlignment == 0);
 
   void *allocation = malloc(amountToAllocate);
 

test/Interpreter/async.swift

@@ -0,0 +1,41 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -Xfrontend -enable-experimental-concurrency %s -module-name main -o %t/main
+// RUN: %target-codesign %t/main
+// RUN: %target-run %t/main | %FileCheck %s
+
+// REQUIRES: concurrency
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: CPU=arm64e
+
+
+func sayHello() async {
+  print("hello")
+}
+
+func sayGeneric<T>(_ msg: T) async {
+  await sayHello()
+  print(msg)
+}
+
+func sayWithClosure(_ action: () async -> ()) async {
+  await action()
+  print("hallo welt")
+}
+
+runAsync {
+  // CHECK: hello
+  await sayHello()
+
+  // CHECK: hello
+  // CHECK: world
+  await sayGeneric("world")
+
+
+  // CHECK: hello
+  // CHECK: and now in german
+  // CHECK: hallo welt
+  await sayWithClosure {
+    await sayHello()
+    print("and now in german")
+  }
+}