Merge branch 'main' into es-sil-pkg

Author: elsh

CMakeLists.txt

@@ -655,6 +655,10 @@ option(SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION
   "Enable build of the Swift observation module"
   FALSE)
 
+option(SWIFT_STDLIB_ENABLE_STRICT_CONCURRENCY_COMPLETE
+  "Build the stdlib with -strict-concurrency=complete"
+  FALSE)
+
 option(SWIFT_ENABLE_SYNCHRONIZATION
   "Enable build of the Swift Synchronization module"
   FALSE)
@@ -802,7 +806,7 @@ if(SWIFT_PATH_TO_CMARK_BUILD)
     OUTPUT_STRIP_TRAILING_WHITESPACE)
   message(STATUS "CMark Version: ${_CMARK_VERSION}")
 elseif(SWIFT_INCLUDE_TOOLS)
-  find_package(cmark-gfm REQUIRED)
+  find_package(cmark-gfm CONFIG REQUIRED)
 endif()
 message(STATUS "")
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -12,7 +12,7 @@
 
 import SIL
 
-private let verbose = true
+private let verbose = false
 
 private func log(_ message: @autoclosure () -> String) {
   if verbose {

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -76,7 +76,14 @@ private func optimizeObjectAllocation(allocRef: AllocRefInstBase, _ context: Fun
     return nil
   }
 
-  guard let endOfInitInst = findEndOfInitialization(of: allocRef) else {
+  guard let endOfInitInst = findEndOfInitialization(
+    of: allocRef,
+    // An object with tail allocated elements is in risk of being passed to malloc_size, which does
+    // not work for non-heap allocated objects. Conservatively, disable objects with tail allocations.
+    // Note, that this does not affect Array because Array always has an end_cow_mutation at the end of
+    // initialization.
+    canStoreToGlobal: allocRef.tailAllocatedCounts.count == 0)
+  else {
     return nil
   }
 
@@ -98,15 +105,15 @@ private func optimizeObjectAllocation(allocRef: AllocRefInstBase, _ context: Fun
 // The end-of-initialization is either an end_cow_mutation, because it guarantees that the originally initialized
 // object is not mutated (it must be copied before mutation).
 // Or it is the store to a global let variable in the global's initializer function.
-private func findEndOfInitialization(of object: Value) -> Instruction? {
+private func findEndOfInitialization(of object: Value, canStoreToGlobal: Bool) -> Instruction? {
   for use in object.uses {
     let user = use.instruction
     switch user {
     case is UpcastInst,
          is UncheckedRefCastInst,
          is MoveValueInst,
          is EndInitLetRefInst:
-      if let ecm = findEndOfInitialization(of: user as! SingleValueInstruction) {
+      if let ecm = findEndOfInitialization(of: user as! SingleValueInstruction, canStoreToGlobal: canStoreToGlobal) {
         return ecm
       }
     case let ecm as EndCOWMutationInst:
@@ -115,7 +122,8 @@ private func findEndOfInitialization(of object: Value) -> Instruction? {
       }
       return ecm
     case let store as StoreInst:
-      if let ga = store.destination as? GlobalAddrInst,
+      if canStoreToGlobal,
+         let ga = store.destination as? GlobalAddrInst,
          ga.global.isLet,
          ga.parentFunction.initializedGlobal == ga.global
       {

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