Merge pull request #71267 from eeckstein/function-signature-opt

MandatoryPerformanceOptimizations: perform function signature optimization to remove metatype arguments

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ReleaseDevirtualizer.swift

@@ -108,7 +108,7 @@ private func tryDevirtualizeRelease(
   let functionRef = builder.createFunctionRef(dealloc)
 
   let substitutionMap: SubstitutionMap
-  if dealloc.isGenericFunction {
+  if dealloc.isGeneric {
     substitutionMap = context.getContextSubstitutionMap(for: type)
   } else {
     // In embedded Swift, dealloc might be a specialized deinit, so the substitution map on the old apply isn't valid for the new apply

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -52,6 +52,13 @@ private func optimizeFunctionsTopDown(using worklist: inout FunctionWorklist,
 
       optimize(function: f, context, &worklist)
     }
+
+    // Generic specialization takes care of removing metatype arguments of generic functions.
+    // But sometimes non-generic functions have metatype arguments which must be removed.
+    // We need handle this case with a function signature optimization.
+    removeMetatypeArgumentsInCallees(of: f, moduleContext)
+
+    worklist.addCallees(of: f)
   }
 }
 
@@ -100,6 +107,11 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ work
           context.diagnosticEngine.diagnose(destroyAddr.location.sourceLoc, .deinit_not_visible)
         }
 
+      case let iem as InitExistentialMetatypeInst:
+        if iem.uses.ignoreDebugUses.isEmpty {
+          context.erase(instructionIncludingDebugUses: iem)
+        }
+
       default:
         break
       }
@@ -111,10 +123,8 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ work
 
     // If this is a just specialized function, try to optimize copy_addr, etc.
     changed = context.optimizeMemoryAccesses(in: function) || changed
-    _ = context.eliminateDeadAllocations(in: function)
+    changed = context.eliminateDeadAllocations(in: function) || changed
   }
-
-  worklist.add(calleesOf: function)
 }
 
 private func specializeVTableAndAddEntriesToWorklist(for type: Type, in function: Function, _ context: FunctionPassContext, _ worklist: inout FunctionWorklist) {
@@ -153,6 +163,14 @@ private func inlineAndDevirtualize(apply: FullApplySite, alreadyInlinedFunctions
   }
 }
 
+private func removeMetatypeArgumentsInCallees(of function: Function, _ context: ModulePassContext) {
+  for inst in function.instructions {
+    if let apply = inst as? FullApplySite {
+      specializeByRemovingMetatypeArguments(apply: apply, context)
+    }
+  }
+}
+
 private func removeUnusedMetatypeInstructions(in function: Function, _ context: FunctionPassContext) {
   for inst in function.instructions {
     if let mt = inst as? MetatypeInst,
@@ -351,7 +369,7 @@ fileprivate struct FunctionWorklist {
   }
 
   mutating func addAllNonGenericFunctions(of moduleContext: ModulePassContext) {
-    for f in moduleContext.functions where !f.isGenericFunction {
+    for f in moduleContext.functions where !f.isGeneric {
       pushIfNotVisited(f)
     }
     return
@@ -366,7 +384,7 @@ fileprivate struct FunctionWorklist {
     }
   }
 
-  mutating func add(calleesOf function: Function) {
+  mutating func addCallees(of function: Function) {
     for inst in function.instructions {
       switch inst {
       case let apply as ApplySite:

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -50,6 +50,12 @@ extension Context {
   }
 
   func getBuiltinIntegerType(bitWidth: Int) -> Type { _bridged.getBuiltinIntegerType(bitWidth).type }
+
+  func lookupFunction(name: String) -> Function? {
+    name._withBridgedStringRef {
+      _bridged.lookupFunction($0).function
+    }
+  }
 }
 
 /// A context which allows mutation of a function's SIL.
@@ -62,6 +68,10 @@ extension MutatingContext {
   func notifyInvalidatedStackNesting() { _bridged.notifyInvalidatedStackNesting() }
   var needFixStackNesting: Bool { _bridged.getNeedFixStackNesting() }
 
+  func verifyIsTransforming(function: Function) {
+    precondition(_bridged.isTransforming(function.bridged), "pass modifies wrong function")
+  }
+
   /// Splits the basic block, which contains `inst`, before `inst` and returns the
   /// new block.
   ///
@@ -88,6 +98,9 @@ extension MutatingContext {
   }
 
   func erase(instruction: Instruction) {
+    if !instruction.isInStaticInitializer {
+      verifyIsTransforming(function: instruction.parentFunction)
+    }
     if instruction is FullApplySite {
       notifyCallsChanged()
     }
@@ -374,18 +387,21 @@ extension Type {
 extension Builder {
   /// Creates a builder which inserts _before_ `insPnt`, using a custom `location`.
   init(before insPnt: Instruction, location: Location, _ context: some MutatingContext) {
+    context.verifyIsTransforming(function: insPnt.parentFunction)
     self.init(insertAt: .before(insPnt), location: location,
               context.notifyInstructionChanged, context._bridged.asNotificationHandler())
   }
 
   /// Creates a builder which inserts _before_ `insPnt`, using the location of `insPnt`.
   init(before insPnt: Instruction, _ context: some MutatingContext) {
+    context.verifyIsTransforming(function: insPnt.parentFunction)
     self.init(insertAt: .before(insPnt), location: insPnt.location,
               context.notifyInstructionChanged, context._bridged.asNotificationHandler())
   }
 
   /// Creates a builder which inserts _after_ `insPnt`, using a custom `location`.
   init(after insPnt: Instruction, location: Location, _ context: some MutatingContext) {
+    context.verifyIsTransforming(function: insPnt.parentFunction)
     if let nextInst = insPnt.next {
       self.init(insertAt: .before(nextInst), location: location,
                 context.notifyInstructionChanged, context._bridged.asNotificationHandler())
@@ -397,17 +413,20 @@ extension Builder {
 
   /// Creates a builder which inserts _after_ `insPnt`, using the location of `insPnt`.
   init(after insPnt: Instruction, _ context: some MutatingContext) {
+    context.verifyIsTransforming(function: insPnt.parentFunction)
     self.init(after: insPnt, location: insPnt.location, context)
   }
 
   /// Creates a builder which inserts at the end of `block`, using a custom `location`.
   init(atEndOf block: BasicBlock, location: Location, _ context: some MutatingContext) {
+    context.verifyIsTransforming(function: block.parentFunction)
     self.init(insertAt: .atEndOf(block), location: location,
               context.notifyInstructionChanged, context._bridged.asNotificationHandler())
   }
 
   /// Creates a builder which inserts at the begin of `block`, using a custom `location`.
   init(atBeginOf block: BasicBlock, location: Location, _ context: some MutatingContext) {
+    context.verifyIsTransforming(function: block.parentFunction)
     let firstInst = block.instructions.first!
     self.init(insertAt: .before(firstInst), location: location,
               context.notifyInstructionChanged, context._bridged.asNotificationHandler())
@@ -416,6 +435,7 @@ extension Builder {
   /// Creates a builder which inserts at the begin of `block`, using the location of the first
   /// instruction of `block`.
   init(atBeginOf block: BasicBlock, _ context: some MutatingContext) {
+    context.verifyIsTransforming(function: block.parentFunction)
     let firstInst = block.instructions.first!
     self.init(insertAt: .before(firstInst), location: firstInst.location,
               context.notifyInstructionChanged, context._bridged.asNotificationHandler())
@@ -444,6 +464,11 @@ extension BasicBlock {
     return bridged.addBlockArgument(type.bridged, ownership._bridged).argument
   }
 
+  func addFunctionArgument(type: Type, _ context: some MutatingContext) -> FunctionArgument {
+    context.notifyInstructionsChanged()
+    return bridged.addFunctionArgument(type.bridged).argument as! FunctionArgument
+  }
+
   func eraseArgument(at index: Int, _ context: some MutatingContext) {
     context.notifyInstructionsChanged()
     bridged.eraseArgument(index)
@@ -585,7 +610,22 @@ extension Function {
     bridged.setNeedStackProtection(needStackProtection)
   }
 
+  func set(thunkKind: ThunkKind, _ context: FunctionPassContext) {
+    context.notifyEffectsChanged()
+    switch thunkKind {
+    case .noThunk:                 bridged.setThunk(.IsNotThunk)
+    case .thunk:                   bridged.setThunk(.IsThunk)
+    case .reabstractionThunk:      bridged.setThunk(.IsReabstractionThunk)
+    case .signatureOptimizedThunk: bridged.setThunk(.IsSignatureOptimizedThunk)
+    }
+  }
+
   func fixStackNesting(_ context: FunctionPassContext) {
     context._bridged.fixStackNesting(bridged)
   }
+
+  func appendNewBlock(_ context: FunctionPassContext) -> BasicBlock {
+    context.notifyBranchesChanged()
+    return context._bridged.appendBlock(bridged).block
+  }
 }

SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift

@@ -123,9 +123,47 @@ struct ModulePassContext : Context, CustomStringConvertible {
     _bridged.endTransformFunction();
   }
 
+  func loadFunction(function: Function, loadCalleesRecursively: Bool) -> Bool {
+    if function.isDefinition {
+      return true
+    }
+    _bridged.loadFunction(function.bridged, loadCalleesRecursively)
+    return function.isDefinition
+  }
+
+  func createSpecializedFunctionDeclaration(
+    name: String,
+    parameters: [ParameterInfo],
+    hasSelfParameter: Bool,
+    fromOriginal originalFunction: Function
+  ) -> Function {
+    return name._withBridgedStringRef { nameRef in
+      let bridgedParamInfos = parameters.map { $0._bridged }
+      return bridgedParamInfos.withUnsafeBufferPointer { paramBuf in
+        _bridged.createSpecializedFunction(nameRef, paramBuf.baseAddress, paramBuf.count,
+                                           hasSelfParameter, originalFunction.bridged).function
+      }
+    }
+  }
+
+  func moveFunctionBody(from sourceFunc: Function, to destFunc: Function) {
+    precondition(!destFunc.isDefinition, "cannot move body to non-empty function")
+    _bridged.moveFunctionBody(sourceFunc.bridged, destFunc.bridged)
+  }
+
   func mangleAsyncRemoved(from function: Function) -> String {
     return String(taking: _bridged.mangleAsyncRemoved(function.bridged))
   }
+
+  func mangle(withDeadArguments: [Int], from function: Function) -> String {
+    withDeadArguments.withUnsafeBufferPointer { bufPtr in
+      bufPtr.withMemoryRebound(to: Int.self) { valPtr in
+        String(taking: _bridged.mangleWithDeadArgs(valPtr.baseAddress,
+                                                   withDeadArguments.count,
+                                                   function.bridged))
+      }
+    }
+  }
 }
 
 extension GlobalVariable {

SwiftCompilerSources/Sources/Optimizer/Utilities/CMakeLists.txt

@@ -13,6 +13,7 @@ swift_compiler_sources(Optimizer
   Devirtualization.swift
   EscapeUtils.swift
   ForwardingUtils.swift
+  FunctionSignatureTransforms.swift
   LifetimeDependenceUtils.swift
   OptUtils.swift
   OwnershipLiveness.swift