Merge branch 'main' into cal--fix-nested-weak-self-issue

Author: calda

Runtimes/Core/CMakeLists.txt

@@ -152,6 +152,8 @@ add_compile_options(
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature FreestandingMacros>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature BitwiseCopyable>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature Extern>"
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature ValueGenerics>"
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-enable-experimental-feature AddressableParameters>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -enable-experimental-concise-pound-file>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -enable-lexical-lifetimes=false>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -disable-implicit-concurrency-module-import>"

Runtimes/Core/cmake/caches/Vendors/Apple/apple-common.cmake

@@ -13,6 +13,6 @@ set(SwiftCore_ENABLE_RUNTIME_FUNCTION_COUNTERS ON CACHE BOOL "")
 set(SwiftCore_ENABLE_BACKDEPLOYMENT_SUPPORT ON CACHE BOOL "")
 set(SwiftCore_ENABLE_FILESYSTEM_SUPPORT ON CACHE BOOL "")
 
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O3 -gline-tables-only -DNDEBUG" CACHE STRING "")
-set(CMAKE_C_FLAGS_RELWITHDEBINFO "-O3 -gline-tables-only -DNDEBUG" CACHE STRING "")
-set(CMAKE_Swift_FLAGS_RELWITHDEBINFO "-O -gline-tables-only" CACHE STRING "")
+set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -g -DNDEBUG" CACHE STRING "")
+set(CMAKE_C_FLAGS_MINSIZEREL "-Os -g -DNDEBUG" CACHE STRING "")
+set(CMAKE_Swift_FLAGS_MINSIZEREL "-Osize -g" CACHE STRING "")

Runtimes/Core/cmake/caches/Vendors/Apple/arm64-BridgeOS.cmake

@@ -8,5 +8,6 @@ set(CMAKE_Swift_COMPILER_TARGET "arm64-apple-bridgeos${CMAKE_OSX_DEPLOYMENT_TARG
 
 set(SwiftCore_ARCH_SUBDIR arm64)
 set(SwiftCore_PLATFORM_SUBDIR freestanding)
+set(CMAKE_BUILD_TYPE MinSizeRel CACHE STRING "")
 
 include("${CMAKE_CURRENT_LIST_DIR}/apple-common.cmake")

Runtimes/Core/core/CMakeLists.txt

@@ -145,6 +145,7 @@ add_library(swiftCore
   SetVariant.swift
   ShadowProtocols.swift
   Shims.swift
+  Slab.swift
   Slice.swift
   SmallString.swift
   Sort.swift
@@ -282,9 +283,14 @@ target_compile_options(swiftCore PRIVATE
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -disable-autolinking-runtime-compatibility-concurrency>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -disable-objc-attr-requires-foundation-module>"
   "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -require-explicit-availability=ignore>"
-  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -prespecialize-generic-metadata>"
-  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xllvm -sil-inline-generics>"
-  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xllvm -sil-partial-specialization>")
+  "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xfrontend -prespecialize-generic-metadata>")
+
+if(NOT "${CMAKE_BUILD_TYPE}" STREQUAL "MinSizeRel")
+  # Using these in MinSizeRel would result in a 15% increase in the binary size
+  target_compile_options(swiftCore PRIVATE
+    "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xllvm -sil-inline-generics>"
+    "$<$<COMPILE_LANGUAGE:Swift>:SHELL:-Xllvm -sil-partial-specialization>")
+endif()
 
 target_compile_definitions(swiftCore PRIVATE
   $<$<BOOL:${SwiftCore_ENABLE_REFLECTION}>:-DSWIFT_ENABLE_REFLECTION>

SwiftCompilerSources/Sources/Optimizer/Analysis/AliasAnalysis.swift

@@ -603,7 +603,7 @@ private enum ImmutableScope {
 
   init?(for basedAddress: Value, _ context: FunctionPassContext) {
     switch basedAddress.enclosingAccessScope {
-    case .scope(let beginAccess):
+    case .access(let beginAccess):
       if beginAccess.isUnsafe {
         return nil
       }
@@ -652,6 +652,9 @@ private enum ImmutableScope {
           return nil
         }
       }
+      case .dependence(let markDep):
+        // ignore mark_dependence for the purpose of alias analysis.
+        self.init(for: markDep.value, context)
     }
   }
 

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -199,21 +199,6 @@ private struct DiagnoseDependence {
     if function.hasUnsafeNonEscapableResult {
       return .continueWalk
     }
-    // FIXME: remove this condition once we have a Builtin.dependence,
-    // which developers should use to model the unsafe
-    // dependence. Builtin.lifetime_dependence will be lowered to
-    // mark_dependence [unresolved], which will be checked
-    // independently. Instead, of this function result check, allow
-    // isUnsafeApplyResult to be used be mark_dependence [unresolved]
-    // without checking its dependents.
-    //
-    // Allow returning an apply result (@_unsafeNonescapableResult) if
-    // the calling function has a dependence. This implicitly makes
-    // the unsafe nonescapable result dependent on the calling
-    // function's lifetime dependence arguments.
-    if dependence.isUnsafeApplyResult, function.hasResultDependence {
-      return .continueWalk
-    }
     // Check that the parameter dependence for this result is the same
     // as the current dependence scope.
     if let arg = dependence.scope.parentValue as? FunctionArgument,

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift

@@ -274,7 +274,8 @@ private extension LifetimeDependence.Scope {
     case let .access(beginAccess):
       // Finding the access base also finds all intermediate nested scopes; there is no need to recursively call
       // gatherExtensions().
-      let (accessBase, nestedAccesses) = beginAccess.accessBaseWithScopes
+      let accessBaseAndScopes = beginAccess.accessBaseWithScopes
+      let accessBase = accessBaseAndScopes.base
       let ownerAddress: Value
       var dependsOnArg: FunctionArgument? = nil
       switch accessBase {
@@ -287,13 +288,18 @@ private extension LifetimeDependence.Scope {
            .pointer, .index:
         ownerAddress = accessBase.address!
       }
-      assert(!nestedAccesses.isEmpty)
-      for nestedAccess in nestedAccesses {
-        innerScopes.push(.access(nestedAccess))
+      assert(!accessBaseAndScopes.scopes.isEmpty)
+      for nestedScope in accessBaseAndScopes.scopes {
+        switch nestedScope {
+        case let .access(beginAccess):
+          innerScopes.push(.access(beginAccess))
+        case .dependence, .base:
+          // ignore recursive mark_dependence base for the purpose of extending scopes. This pass will extend the base
+          // of that mark_dependence (if it is unresolved) later as a separate LifetimeDependence.Scope.
+          break
+        }
       }
-      // This is the outermost scope. We only see nested access scopes after inlining.
-      //
-      // TODO: could we have a nested access within an yielded inout address?
+      // TODO: could we have a nested access within an yielded inout address prior to inlining?
       return SingleInlineArray(element: ScopeExtension(owner: ownerAddress, nestedScopes: innerScopes,
                                                        dependsOnArg: dependsOnArg))
     case let .borrowed(beginBorrow):

SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift

@@ -215,6 +215,11 @@ extension AccessBase {
         return nil
       }
       baseAddr = arg
+    case let .storeBorrow(sbi):
+      guard case let .stack(allocStack) = sbi.destinationOperand.value.accessBase else {
+        return nil
+      }
+      return (initialAddress: allocStack, initializingStore: sbi)
     default:
       return nil
     }

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -117,7 +117,7 @@ struct LifetimeDependence : CustomStringConvertible {
     case yield(Value)
     /// An owned value whose OSSA lifetime encloses nonescapable values, or a trivial variable introduced by move_value.
     case owned(Value)
-    /// An borrowed value whose OSSA lifetime encloses nonescapable values, or a trivial variable introduced by
+    /// A borrowed value whose OSSA lifetime encloses nonescapable values, or a trivial variable introduced by
     /// begin_borrow.
     case borrowed(BeginBorrowValue)
     /// Singly-initialized addressable storage (likely for an
@@ -225,16 +225,6 @@ extension LifetimeDependence {
     self.dependentValue = value
   }
 
-  var isUnsafeApplyResult: Bool {
-    if case let .owned(value) = scope {
-      if let apply = value.definingInstruction as? FullApplySite {
-        assert(!apply.hasResultDependence)
-        return true
-      }
-    }
-    return false
-  }
-
   /// Construct LifetimeDependence from mark_dependence [unresolved] or mark_dependence [nonescaping].
   ///
   /// For any LifetimeDependence constructed from a mark_dependence, its `dependentValue` will be the result of the
@@ -313,10 +303,15 @@ extension LifetimeDependence.Scope {
 
   private init(address: Value, _ context: some Context) {
     switch address.enclosingAccessScope {
-    case let .scope(access):
+    case let .access(access):
       self = .access(access)
     case let .base(accessBase):
       self = Self(accessBase: accessBase, address: address, context)
+    case let .dependence(markDep):
+      // The current dependence only represents the forwarded address. If the mark_dependence instruction encoutered
+      // here is [unresolved], then a separate LifetimeDependence.Scope will be created for it, and if it is [escaping],
+      // then it is ignored for the purpose of lifetime dependence.
+      self.init(address: markDep.value, context)
     }
   }
 
@@ -334,7 +329,11 @@ extension LifetimeDependence.Scope {
       self = Self(guaranteed: refElt.operand.value, context)
     case let .argument(arg):
       if arg.convention.isIndirectIn {
-        self = .initialized(initialAddress: arg, initializingStore: nil)
+        if arg.convention.isGuaranteed {
+          self = .caller(arg)
+        } else {
+          self = .initialized(initialAddress: arg, initializingStore: nil)
+        }
       } else if arg.convention.isIndirectOut || arg.convention.isInout {
         // TODO: verify that @out values are never reassigned.
         self = .caller(arg)
@@ -482,7 +481,12 @@ extension LifetimeDependence.Scope {
     }
   }
 
-  // !!! - handle allocations of trivial values: no destroy. Use the dealloc in that case?
+  // Note: an initialized range should always have a destroy_addr. For trivial 'var' variables, we have a alloc_box,
+  // which has a destroy_value. For concrete trivial 'let' variables, we load the trivial value:
+  //   %l = load [trivial] %0
+  //   %m = move_value [var_decl] %2
+  //
+  // For generic trivial (BitwiseCopyable) 'let' variables, we emit a destroy_addr for the alloc_stack.
   private static func computeInitializedRange(initialAddress: Value, initializingStore: Instruction?,
                                               _ context: Context)
     -> InstructionRange {
@@ -633,12 +637,34 @@ struct VariableIntroducerUseDefWalker : LifetimeDependenceUseDefWalker {
 
   mutating func walkUp(address: Value) -> WalkResult {
     if let beginAccess = address.definingInstruction as? BeginAccessInst {
+      // Treat calls to unsafe[Mutable]Address like a projection of 'self' rather than a separate variable access.
+      if let addressorSelf = beginAccess.unsafeAddressorSelf {
+        return walkUp(valueOrAddress: addressorSelf)
+      }
       return introducer(beginAccess, nil)
     }
     return walkUpDefault(address: address)
   }
 }
 
+private extension BeginAccessInst {
+  // Recognize an access scope for a unsafe addressor:
+  // %adr = pointer_to_address
+  // %md = mark_dependence %adr
+  // begin_access [unsafe] %md
+  var unsafeAddressorSelf: Value? {
+    guard isUnsafe else {
+      return nil
+    }
+    let accessBaseAndScopes = address.accessBaseWithScopes
+    guard case .pointer = accessBaseAndScopes.base,
+          case let .dependence(markDep) = accessBaseAndScopes.scopes.first else {
+      return nil
+    }
+    return markDep.base
+  }
+}
+
 /// Walk up the lifetime dependence chain.
 ///
 /// This finds the introducers of a dependence chain. which represent the value's "inherited" dependencies. This stops
@@ -1151,7 +1177,7 @@ extension LifetimeDependenceDefUseWalker {
 
     // Get the local variable access that encloses this store.
     var storeAccess = storedOperand.instruction
-    if case let .scope(beginAccess) = storeAddress.enclosingAccessScope {
+    if case let .access(beginAccess) = storeAddress.enclosingAccessScope {
       storeAccess = beginAccess
     }
     if !localReachability.gatherAllReachableUses(of: storeAccess, in: &accessStack) {

SwiftCompilerSources/Sources/SIL/Utilities/AccessUtils.swift

@@ -477,7 +477,7 @@ private extension PointerToAddressInst {
   }
 }
 
-/// The `EnclosingScope` of an access is the innermost `begin_access`
+/// The `EnclosingAccessScope` of an access is the innermost `begin_access`
 /// instruction that checks for exclusivity of the access.
 /// If there is no `begin_access` instruction found, then the scope is
 /// the base itself.
@@ -497,13 +497,29 @@ private extension PointerToAddressInst {
 /// %l3 = load %a3 : $*Int64
 /// end_access %a3 : $*Int64
 /// ```
-public enum EnclosingScope {
-  case scope(BeginAccessInst)
+public enum EnclosingAccessScope {
+  case access(BeginAccessInst)
   case base(AccessBase)
+  case dependence(MarkDependenceInst)
+}
+
+// An AccessBase with the nested enclosing scopes that contain the original address in bottom-up order.
+public struct AccessBaseAndScopes {
+  public let base: AccessBase
+  public let scopes: SingleInlineArray<EnclosingAccessScope>
+
+  public var innermostAccess: BeginAccessInst? {
+    for scope in scopes {
+      if case let .access(beginAccess) = scope {
+        return beginAccess
+      }
+    }
+    return nil
+  }
 }
 
 private struct EnclosingAccessWalker : AddressUseDefWalker {
-  var enclosingScope: EnclosingScope?
+  var enclosingScope: EnclosingAccessScope?
 
   mutating func walk(startAt address: Value, initialPath: UnusedWalkingPath = UnusedWalkingPath()) {
     if walkUp(address: address, path: UnusedWalkingPath()) == .abortWalk {
@@ -522,19 +538,24 @@ private struct EnclosingAccessWalker : AddressUseDefWalker {
   }
 
   mutating func walkUp(address: Value, path: UnusedWalkingPath) -> WalkResult {
-    if let ba = address as? BeginAccessInst {
-      enclosingScope = .scope(ba)
+    switch address {
+    case let ba as BeginAccessInst:
+      enclosingScope = .access(ba)
       return .continueWalk
+    case let md as MarkDependenceInst:
+      enclosingScope = .dependence(md)
+      return .continueWalk
+    default:
+      return walkUpDefault(address: address, path: path)
     }
-    return walkUpDefault(address: address, path: path)
   }
 }
 
 private struct AccessPathWalker : AddressUseDefWalker {
   var result = AccessPath.unidentified()
 
-  // List of nested BeginAccessInst: inside-out order.
-  var foundBeginAccesses = SingleInlineArray<BeginAccessInst>()
+  // List of nested BeginAccessInst & MarkDependenceInst: inside-out order.
+  var foundEnclosingScopes = SingleInlineArray<EnclosingAccessScope>()
 
   let enforceConstantProjectionPath: Bool
 
@@ -602,7 +623,9 @@ private struct AccessPathWalker : AddressUseDefWalker {
       // projection. Bail out
       return .abortWalk
     } else if let ba = address as? BeginAccessInst {
-      foundBeginAccesses.push(ba)
+      foundEnclosingScopes.push(.access(ba))
+    } else if let md = address as? MarkDependenceInst {
+      foundEnclosingScopes.push(.dependence(md))
     }
     return walkUpDefault(address: address, path: path.with(indexAddr: false))
   }
@@ -655,20 +678,21 @@ extension Value {
   public var accessPathWithScope: (AccessPath, scope: BeginAccessInst?) {
     var walker = AccessPathWalker()
     walker.walk(startAt: self)
-    return (walker.result, walker.foundBeginAccesses.first)
+    let baseAndScopes = AccessBaseAndScopes(base: walker.result.base, scopes: walker.foundEnclosingScopes)
+    return (walker.result, baseAndScopes.innermostAccess)
   }
 
   /// Computes the enclosing access scope of this address value.
-  public var enclosingAccessScope: EnclosingScope {
+  public var enclosingAccessScope: EnclosingAccessScope {
     var walker = EnclosingAccessWalker()
     walker.walk(startAt: self)
     return walker.enclosingScope ?? .base(.unidentified)
   }
 
-  public var accessBaseWithScopes: (AccessBase, SingleInlineArray<BeginAccessInst>) {
+  public var accessBaseWithScopes: AccessBaseAndScopes {
     var walker = AccessPathWalker()
     walker.walk(startAt: self)
-    return (walker.result.base, walker.foundBeginAccesses)
+    return AccessBaseAndScopes(base: walker.result.base, scopes: walker.foundEnclosingScopes)
   }
 
   /// The root definition of a reference, obtained by skipping ownership forwarding and ownership transition.