[IRGen] Don't mark calls to swift_task_alloc as 'readnone'.

Doing so causes later passes to coalesce swift_task_alloc calls.

Author: DougGregor

lib/IRGen/IRGenFunction.cpp

@@ -495,8 +495,6 @@ Address IRGenFunction::emitTaskAlloc(llvm::Value *size, Alignment alignment) {
   auto *call = Builder.CreateCall(IGM.getTaskAllocFn(), {getAsyncTask(), size});
   call->setDoesNotThrow();
   call->setCallingConv(IGM.SwiftCC);
-  call->addAttribute(llvm::AttributeList::FunctionIndex,
-                     llvm::Attribute::ReadNone);
   auto address = Address(call, alignment);
   return address;
 }

test/Concurrency/Runtime/basic_future.swift

@@ -3,7 +3,7 @@
 // REQUIRES: executable_test
 // REQUIRES: concurrency
 // REQUIRES: OS=macosx
-// REQUIRES: CPU=x86_64
+// XFAIL: CPU=arm64e
 
 import Dispatch
 

test/Concurrency/Runtime/future_fibonacci.swift

@@ -0,0 +1,87 @@
+// RUN: %target-run-simple-swift(-Xfrontend -enable-experimental-concurrency)
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: OS=macosx
+// XFAIL: CPU=arm64e
+
+import Dispatch
+
+extension DispatchQueue {
+  func async<R>(execute: @escaping () async throws -> R) -> Task.Handle<R> {
+    let handle = Task.runDetached(operation: execute)
+
+    // Run the task
+    _ = { self.async { handle.run() } }()
+
+    return handle
+  }
+
+  func async<R>(in group: DispatchGroup,
+    execute: @escaping () async throws -> R) -> Task.Handle<R> {
+    let handle = Task.runDetached(operation: execute)
+
+    // Run the task
+    group.enter()
+    _ = {
+      self.async {
+        handle.run()
+        group.leave()
+      }
+    }()
+
+    return handle
+  }
+}
+
+func fib(_ n: Int) -> Int {
+    var first = 0
+    var second = 1
+    for _ in 0..<n {
+        let temp = first
+        first = second
+        second = temp + first
+    }
+    return first
+}
+
+func asyncFib(_ n: Int, group: DispatchGroup, queue: DispatchQueue) async -> Int {
+  if n == 0 || n == 1 {
+    return n
+  }
+
+  let first = queue.async(in: group) {
+    await asyncFib(n - 2, group: group, queue: queue)
+  }
+
+  let second = queue.async(in: group) {
+    await asyncFib(n - 1, group: group, queue: queue)
+  }
+
+  // Sleep a random amount of time waiting on the result producing a result.
+  usleep(UInt32.random(in: 0..<100) * 1000)
+
+  let result = await try! first.get() + second.get()
+
+  // Sleep a random amount of time before producing a result.
+  usleep(UInt32.random(in: 0..<100) * 1000)
+
+  return result
+}
+
+func runFibonacci(_ n: Int) {
+  let queue = DispatchQueue(label: "concurrent", attributes: .concurrent)
+  let group = DispatchGroup()
+
+  var result = 0
+  _ = queue.async(in: group) {
+    result = await asyncFib(n, group: group, queue: queue)
+  }
+  group.wait()
+
+  print()
+  print("Async fib = \(result), sequential fib = \(fib(n))")
+  assert(result == fib(n))
+}
+
+runFibonacci(15)