[SILOpt] experimental async demotion pass

For chains of async functions where suspensions can be statically
proven to never be required, this pass removes all suspensions and
turns the functions into synchronous functions.

For example, this function does not actually require any suspensions,
once the correct executor is acquired upon initial entry:

```
func fib(_ n: Int) async -> Int {
  if n <= 1 { return n }
  return await fib(n-1) + fib(n-2)
}
```

So we can turn the above into this for better performance:

```
func fib() async -> Int {
  return fib_sync()
}

func fib_sync(_ n: Int) -> Int {
  if n <= 1 { return n }
  return fib(n-1) + fib(n-2)
}
```

while rewriting callers of `fib` to use the `sync` entry-point
when we can prove that it will be invoked on a compatible executor.

This pass is currently experimental and under development. Thus, it
is disabled by default and you must use
`-enable-experimental-async-demotion` to try it.

Author: kavon

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AsyncDemotion.swift

@@ -8,6 +8,7 @@
 
 swift_compiler_sources(Optimizer
   AssumeSingleThreaded.swift
+  AsyncDemotion.swift
   CleanupDebugSteps.swift
   ComputeEscapeEffects.swift
   ComputeSideEffects.swift

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -123,6 +123,11 @@ struct ModulePassContext : Context, CustomStringConvertible {
     runOnFunction(FunctionPassContext(_bridged: _bridged))
     _bridged.endTransformFunction();
   }
+
+  func mangleAsyncRemoved(from function: Function) -> String {
+    let stdString = _bridged.mangleAsyncRemoved(function.bridged)
+    return String(_cxxString: stdString)
+  }
 }
 
 extension GlobalVariable {

SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift

@@ -66,6 +66,7 @@ private func registerSwiftPasses() {
   registerPass(stackProtection, { stackProtection.run($0) })
 
   // Function passes
+  registerPass(asyncDemotion, { asyncDemotion.run($0) })
   registerPass(letPropertyLowering, { letPropertyLowering.run($0) })
   registerPass(mergeCondFailsPass, { mergeCondFailsPass.run($0) })
   registerPass(computeEscapeEffects, { computeEscapeEffects.run($0) })

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -67,6 +67,10 @@ public protocol ApplySite : Instruction {
 extension ApplySite {
   public var callee: Value { operands[ApplyOperands.calleeOperandIndex].value }
 
+  public var isAsync: Bool {
+    return callee.type.isAsyncFunction
+  }
+
   /// Returns the subset of operands which are argument operands.
   ///
   /// This does not include the callee function operand.

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -43,6 +43,10 @@ final public class FunctionArgument : Argument {
     bridged.getConvention().convention
   }
 
+  public var isSelf: Bool {
+    return bridged.isSelf()
+  }
+
   public var isIndirectResult: Bool {
     return index < parentFunction.numIndirectResultArguments
   }

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -92,6 +92,10 @@ public class Instruction : CustomStringConvertible, Hashable {
   final public var mayWriteToMemory: Bool { memoryEffects.write }
   final public var mayReadOrWriteMemory: Bool { memoryEffects.read || memoryEffects.write }
 
+  public final var maySuspend: Bool {
+    return bridged.maySuspend()
+  }
+
   public final var mayRelease: Bool {
     return bridged.mayRelease()
   }
@@ -338,6 +342,8 @@ final public class CondFailInst : Instruction, UnaryInstruction {
   public var message: String { bridged.CondFailInst_getMessage().string }
 }
 
+final public class HopToExecutorInst : Instruction, UnaryInstruction {}
+
 final public class FixLifetimeInst : Instruction, UnaryInstruction {}
 
 final public class DebugValueInst : Instruction, UnaryInstruction {}
@@ -745,6 +751,13 @@ class ValueToBridgeObjectInst : SingleValueInstruction, UnaryInstruction {
   public var value: Value { return operand.value }
 }
 
+final public
+class GetAsyncContinuationInst : SingleValueInstruction {}
+
+final public
+class GetAsyncContinuationAddrInst : SingleValueInstruction, UnaryInstruction {}
+
+
 final public
 class MarkDependenceInst : SingleValueInstruction {
   public var value: Value { return operands[0].value }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -46,6 +46,7 @@ public func registerSILClasses() {
   register(EndAccessInst.self)
   register(EndBorrowInst.self)
   register(CondFailInst.self)
+  register(HopToExecutorInst.self)
   register(MarkUninitializedInst.self)
   register(FixLifetimeInst.self)
   register(DebugValueInst.self)
@@ -133,6 +134,8 @@ public func registerSILClasses() {
   register(RefToBridgeObjectInst.self)
   register(BridgeObjectToRefInst.self)
   register(BridgeObjectToWordInst.self)
+  register(GetAsyncContinuationInst.self)
+  register(GetAsyncContinuationAddrInst.self)
   register(BeginAccessInst.self)
   register(BeginBorrowInst.self)
   register(ProjectBoxInst.self)

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -57,6 +57,7 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
   public var isFunction: Bool { bridged.isFunction() }
   public var isMetatype: Bool { bridged.isMetatype() }
   public var isNoEscapeFunction: Bool { bridged.isNoEscapeFunction() }
+  public var isAsyncFunction: Bool { bridged.isAsyncFunction() }
 
   public var canBeClass: swift.TypeTraitResult { bridged.canBeClass() }
 
@@ -198,7 +199,7 @@ extension swift.SILType {
 }
 
 // TODO: use an AST type for this once we have it
-public struct NominalTypeDecl : Equatable {
+public struct NominalTypeDecl : Equatable, Hashable {
   private let bridged: BridgedNominalTypeDecl
 
   public init(_bridged: BridgedNominalTypeDecl) {
@@ -211,7 +212,15 @@ public struct NominalTypeDecl : Equatable {
     lhs.bridged.decl == rhs.bridged.decl
   }
 
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(bridged.decl)
+  }
+
   public var isStructWithUnreferenceableStorage: Bool {
     bridged.isStructWithUnreferenceableStorage()
   }
+
+  public var isGlobalActor: Bool {
+    return bridged.isGlobalActor()
+  }
 }

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -117,6 +117,9 @@ class SILOptions {
   /// Controls whether to emit actor data-race checks.
   bool EnableActorDataRaceChecks = false;
 
+  /// Controls whether to run async demotion pass.
+  bool EnableAsyncDemotion = false;
+
   /// Should we run any SIL performance optimizations
   ///
   /// Useful when you want to enable -O LLVM opts but not -O SIL opts.