Merge branch 'release/6.2' into 62-reassign-immortal

atrick · web-flow · commit 5e11357227f8 · 2025-07-07T08:38:07.000-07:00
diff --git a/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LetPropertyLowering.swift b/SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LetPropertyLowering.swift
@@ -122,6 +122,8 @@ private func insertEndInitInstructions(
       use.set(to: ssaUpdater.getValue(atEndOf: use.instruction.parentBlock), context)
     }
   }
+  // This peephole optimization is required to avoid ownership errors.
+  replacePhisWithIncomingValues(phis: ssaUpdater.insertedPhis, context)
 }
 
 private func constructLetInitRegion(
diff --git a/SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift b/SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift
@@ -122,7 +122,8 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
           }
         }
       case let metatype as MetatypeInst:
-        if context.options.enableEmbeddedSwift {
+        if context.options.enableEmbeddedSwift,
+           metatype.type.representationOfMetatype == .thick {
           let instanceType = metatype.type.loweredInstanceTypeOfMetatype(in: function)
           if instanceType.isClass {
             specializeVTable(forClassType: instanceType, errorLocation: metatype.location, moduleContext) {
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift
@@ -648,12 +648,10 @@ extension AddressOwnershipLiveRange {
 let addressOwnershipLiveRangeTest = FunctionTest("address_ownership_live_range") {
   function, arguments, context in
   let address = arguments.takeValue()
+  let begin = arguments.takeInstruction()
   print("Address: \(address)")
   print("Base: \(address.accessBase)")
-  let begin = address.definingInstructionOrTerminator ?? {
-    assert(address is FunctionArgument)
-    return function.instructions.first!
-  }()
+  print("Begin: \(begin)")
   let localReachabilityCache = LocalVariableReachabilityCache()
   guard var ownershipRange = AddressOwnershipLiveRange.compute(for: address, at: begin,
                                                                localReachabilityCache, context) else {
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift
@@ -640,7 +640,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     }
 
     // Indirect arguments cannot escape the function, but loaded values from such can.
-    if !followLoads(at: path) {
+    if argOp.value.type.isAddress && !followLoads(at: path) {
       if let beginApply = apply as? BeginApplyInst {
         // begin_apply can yield an address value.
         if !indirectResultEscapes(of: beginApply, path: path) {
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift
@@ -975,6 +975,8 @@ extension LifetimeDependenceDefUseWalker {
       return yieldedDependence(result: localAccess.operand!)
     case .incomingArgument:
       fatalError("Incoming arguments are never reachable")
+    case .deadEnd:
+      return .continueWalk
     }
   }
 
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/LocalVariableUtils.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/LocalVariableUtils.swift
@@ -72,6 +72,7 @@ struct LocalVariableAccess: CustomStringConvertible {
     case storeBorrow // scoped initialization of temporaries
     case apply       // indirect arguments
     case escape      // alloc_box captures
+    case deadEnd     // unreachable
   }
   let kind: Kind
   // All access have an operand except .incomingArgument and .outgoingArgument.
@@ -102,7 +103,7 @@ struct LocalVariableAccess: CustomStringConvertible {
       case .`init`, .modify:
         return true
       }
-    case .load, .dependenceSource, .dependenceDest:
+    case .load, .dependenceSource, .dependenceDest, .deadEnd:
       return false
     case .incomingArgument, .outgoingArgument, .store, .storeBorrow, .inoutYield:
       return true
@@ -153,6 +154,8 @@ struct LocalVariableAccess: CustomStringConvertible {
       str += "apply"
     case .escape:
       str += "escape"
+    case .deadEnd:
+      str += "deadEnd"
     }
     if let inst = instruction {
       str += "\(inst)"
@@ -201,7 +204,7 @@ class LocalVariableAccessInfo: CustomStringConvertible {
       self.hasEscaped = true
     case .inoutYield:
       self._isFullyAssigned = false
-    case .incomingArgument, .outgoingArgument:
+    case .incomingArgument, .outgoingArgument, .deadEnd:
       fatalError("Function arguments are never mapped to LocalVariableAccessInfo")
     }
   }
@@ -753,8 +756,8 @@ extension LocalVariableReachableAccess {
   ///
   /// This does not include the destroy or reassignment of the value set by `modifyInst`.
   ///
-  /// Returns true if all possible reachable uses were visited. Returns false if any escapes may reach `modifyInst` are
-  /// reachable from `modifyInst`.
+  /// Returns true if all possible reachable uses were visited. Returns false if any escapes may reach `modifyInst` or
+  /// are reachable from `modifyInst`.
   ///
   /// This does not gather the escaping accesses themselves. When escapes are reachable, it also does not guarantee that
   /// previously reachable accesses are gathered.
@@ -855,6 +858,8 @@ extension LocalVariableReachableAccess {
       }
       if block.terminator.isFunctionExiting {
         accessStack.push(LocalVariableAccess(.outgoingArgument, block.terminator))
+      } else if block.successors.isEmpty {
+        accessStack.push(LocalVariableAccess(.deadEnd, block.terminator))
       } else {
         for successor in block.successors { blockList.pushIfNotVisited(successor) }
       }
diff --git a/SwiftCompilerSources/Sources/Optimizer/Utilities/SSAUpdater.swift b/SwiftCompilerSources/Sources/Optimizer/Utilities/SSAUpdater.swift
@@ -50,4 +50,14 @@ struct SSAUpdater<Context: MutatingContext> {
     context.notifyInstructionsChanged()
     return context._bridged.SSAUpdater_getValueInMiddleOfBlock(block.bridged).value
   }
+
+  var insertedPhis: [Phi] {
+    var phis = [Phi]()
+    let numPhis = context._bridged.SSAUpdater_getNumInsertedPhis()
+    phis.reserveCapacity(numPhis)
+    for idx in 0..<numPhis {
+      phis.append(Phi(context._bridged.SSAUpdater_getInsertedPhi(idx).value)!)
+    }
+    return phis
+  }
 }
diff --git a/include/swift/SILOptimizer/OptimizerBridging.h b/include/swift/SILOptimizer/OptimizerBridging.h
@@ -367,6 +367,8 @@ struct BridgedPassContext {
   BRIDGED_INLINE void SSAUpdater_addAvailableValue(BridgedBasicBlock block, BridgedValue value) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedValue SSAUpdater_getValueAtEndOfBlock(BridgedBasicBlock block) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedValue SSAUpdater_getValueInMiddleOfBlock(BridgedBasicBlock block) const;
+  BRIDGED_INLINE SwiftInt SSAUpdater_getNumInsertedPhis() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedValue SSAUpdater_getInsertedPhi(SwiftInt idx) const;
 
   // Options
 
diff --git a/include/swift/SILOptimizer/OptimizerBridgingImpl.h b/include/swift/SILOptimizer/OptimizerBridgingImpl.h
@@ -548,6 +548,14 @@ BridgedValue BridgedPassContext::SSAUpdater_getValueInMiddleOfBlock(BridgedBasic
       invocation->getSSAUpdater()->getValueInMiddleOfBlock(block.unbridged())};
 }
 
+SwiftInt BridgedPassContext::SSAUpdater_getNumInsertedPhis() const {
+  return (SwiftInt)invocation->getInsertedPhisBySSAUpdater().size();
+}
+
+BridgedValue BridgedPassContext::SSAUpdater_getInsertedPhi(SwiftInt idx) const {
+  return {invocation->getInsertedPhisBySSAUpdater()[idx]};
+}
+
 bool BridgedPassContext::enableStackProtection() const {
   swift::SILModule *mod = invocation->getPassManager()->getModule();
   return mod->getOptions().EnableStackProtection;
diff --git a/include/swift/SILOptimizer/PassManager/PassManager.h b/include/swift/SILOptimizer/PassManager/PassManager.h
@@ -75,6 +75,7 @@ class SwiftPassInvocation {
   SILModule::SlabList allocatedSlabs;
 
   SILSSAUpdater *ssaUpdater = nullptr;
+  SmallVector<SILPhiArgument *, 4> insertedPhisBySSAUpdater;
 
   SwiftPassInvocation *nestedSwiftPassInvocation = nullptr;
 
@@ -178,8 +179,9 @@ class SwiftPassInvocation {
 
   void initializeSSAUpdater(SILFunction *fn, SILType type,
                             ValueOwnershipKind ownership) {
+    insertedPhisBySSAUpdater.clear();
     if (!ssaUpdater)
-      ssaUpdater = new SILSSAUpdater;
+      ssaUpdater = new SILSSAUpdater(&insertedPhisBySSAUpdater);
     ssaUpdater->initialize(fn, type, ownership);
   }
 
@@ -188,6 +190,8 @@ class SwiftPassInvocation {
     return ssaUpdater;
   }
 
+  ArrayRef<SILPhiArgument *> getInsertedPhisBySSAUpdater() { return insertedPhisBySSAUpdater; }
+
   SwiftPassInvocation *initializeNestedSwiftPassInvocation(SILFunction *newFunction) {
     assert(!nestedSwiftPassInvocation && "Nested Swift pass invocation already initialized");
     nestedSwiftPassInvocation = new SwiftPassInvocation(passManager, transform, newFunction);
diff --git a/lib/SILOptimizer/PassManager/PassManager.cpp b/lib/SILOptimizer/PassManager/PassManager.cpp
@@ -1562,6 +1562,7 @@ irgen::IRGenModule *SwiftPassInvocation::getIRGenModule() {
 }
 
 void SwiftPassInvocation::endPass() {
+  insertedPhisBySSAUpdater.clear();
   assert(allocatedSlabs.empty() && "StackList is leaking slabs");
   assert(numBlockSetsAllocated == 0 && "Not all BasicBlockSets deallocated");
   assert(numNodeSetsAllocated == 0 && "Not all NodeSets deallocated");
diff --git a/test/SILOptimizer/addr_escape_info.sil b/test/SILOptimizer/addr_escape_info.sil
@@ -956,3 +956,21 @@ bb0(%0 : $Int):
   %9 = tuple ()
   return %9 : $()
 }
+
+// CHECK-LABEL: Address escape information for escaping_pointer_through_function:
+// CHECK:       value:  %1 = alloc_stack $Int
+// CHECK-NEXT:    ==>   %4 = apply undef(%3) : $@convention(thin) (Builtin.RawPointer) -> UnsafeMutableRawBufferPointer
+// CHECK-NEXT:    ==>   %5 = apply undef(%4) : $@convention(thin) (UnsafeMutableRawBufferPointer) -> ()
+// CHECK-NEXT:  End function escaping_pointer_through_function
+sil [ossa] @escaping_pointer_through_function : $@convention(thin) (Int) -> () {
+bb0(%0 : $Int):
+  %1 = alloc_stack $Int
+  fix_lifetime %1
+  %3 = address_to_pointer %1 to $Builtin.RawPointer
+  %4 = apply undef(%3) : $@convention(thin) (Builtin.RawPointer) -> UnsafeMutableRawBufferPointer
+  %5 = apply undef(%4) : $@convention(thin) (UnsafeMutableRawBufferPointer) -> ()
+  dealloc_stack %1
+  %7 = tuple ()
+  return %7
+}
+
diff --git a/test/SILOptimizer/let-property-lowering.sil b/test/SILOptimizer/let-property-lowering.sil
@@ -311,3 +311,34 @@ bb1(%3a : @reborrow $C):
   return %2 : $C
 }
 
+
+// CHECK-LABEL: sil [ossa] @test_no_phis :
+// CHECK:         %3 = end_init_let_ref %2
+// CHECK:         return %3
+// CHECK:       } // end sil function 'test_no_phis'
+sil [ossa] @test_no_phis : $@convention(thin) (Int, @owned C) -> @owned C {
+bb0(%0 : $Int, %1 : @owned $C):
+  %2 = mark_uninitialized [rootself] %1
+  %3 = begin_borrow %2
+  cond_br undef, bb1, bb2
+bb1:
+  br bb7
+bb2:
+  cond_br undef, bb3, bb8
+bb3:
+  cond_br undef, bb4, bb5
+bb4:
+  br bb7
+bb5:
+  br bb6
+bb6:
+  end_borrow %3
+  return %2
+bb7:
+  br bb6
+bb8:
+  end_borrow %3
+  destroy_value [dead_end] %2
+  unreachable
+}
+
diff --git a/test/SILOptimizer/lifetime_dependence/scope_fixup.sil b/test/SILOptimizer/lifetime_dependence/scope_fixup.sil
@@ -119,6 +119,13 @@ class C {
 
 sil @C_read : $@yield_once @convention(method) (@guaranteed C) -> @yields @guaranteed Optional<NCWrapper>
 
+struct S {
+  let c: C
+}
+struct MutNE: ~Copyable & ~Escapable {}
+
+sil @getMutNE : $@convention(thin) (@inout S) -> @lifetime(borrow 0) @owned MutNE
+
 // NCContainer.wrapper._read:
 //   var wrapper: Wrapper {
 //     _read {
@@ -791,3 +798,54 @@ bb2:
   %42 = tuple ()
   return %42
 }
+
+// rdar://154406790 (Lifetime-dependent variable 'X' escapes its scope but only if actor/class is final)
+//
+// The end_access must be extended into the unreachable block past the end_borrow.
+//
+// CHECK-LABEL: sil hidden [ossa] @testInoutAtModify : $@convention(thin) (@inout S) -> () {
+// CHECK: bb0(%0 : $*S):
+// CHECK:   [[ACCESS:%[0-9]+]] = begin_access [modify] [unknown] %0
+// CHECK:   apply %{{.*}}([[ACCESS]]) : $@convention(thin) (@inout S) -> @lifetime(borrow 0) @owned MutNE
+// CHECK:   mark_dependence [unresolved] %{{.*}} on [[ACCESS]]
+// CHECK:   [[LB:%[0-9]+]] = load_borrow
+//
+// CHECK: bb1:
+// CHECK:   end_borrow [[LB]]
+// CHECK:   end_access [[ACCESS]]
+// CHECK:   return %16
+//
+// CHECK: bb2:
+// CHECK:   end_borrow [[LB]]
+// CHECK:   end_access [[ACCESS]]
+// CHECK:   unreachable
+// CHECK-LABEL: } // end sil function 'testInoutAtModify'
+sil hidden [ossa] @testInoutAtModify : $@convention(thin) (@inout S) -> () {
+bb0(%0 : $*S):
+  %1 = alloc_box ${ let MutNE }, let, name "ne"
+  %2 = begin_borrow [lexical] [var_decl] %1
+  %3 = project_box %2, 0
+  %4 = begin_access [modify] [unknown] %0
+
+  %6 = function_ref @getMutNE : $@convention(thin) (@inout S) -> @lifetime(borrow 0) @owned MutNE
+  %7 = apply %6(%4) : $@convention(thin) (@inout S) -> @lifetime(borrow 0) @owned MutNE
+  %8 = mark_dependence [unresolved] %7 on %4
+  store %8 to [init] %3
+  end_access %4
+  %11 = mark_unresolved_non_copyable_value [no_consume_or_assign] %3
+  %12 = load_borrow %11
+  cond_br undef, bb1, bb2
+
+bb1:
+  end_borrow %12
+  end_borrow %2
+  destroy_value %1
+  %15 = tuple ()
+  return %15
+
+bb2:
+  end_borrow %12
+  end_borrow %2
+  dealloc_box [dead_end] %1
+  unreachable
+}
diff --git a/test/SILOptimizer/lifetime_dependence/verify_diagnostics.swift b/test/SILOptimizer/lifetime_dependence/verify_diagnostics.swift
@@ -275,6 +275,19 @@ func testSwitchAddr<T>(holder: inout Holder, t: T) {
   mutableView.modify()
 }
 
+// =============================================================================
+// Throwing
+// =============================================================================
+
+@available(Span 0.1, *)
+func mutableSpanMayThrow(_: borrowing MutableSpan<Int>) throws {}
+
+@available(Span 0.1, *)
+func testSpanMayThrow(buffer: inout [Int]) {
+  let bufferSpan = buffer.mutableSpan
+  try! mutableSpanMayThrow(bufferSpan)
+}
+
 // =============================================================================
 // inout
 // =============================================================================
diff --git a/test/SILOptimizer/ownership_utils/address_ownership_live_range.sil b/test/SILOptimizer/ownership_utils/address_ownership_live_range.sil
diff --git a/test/SILOptimizer/redundant_load_elim_ossa.sil b/test/SILOptimizer/redundant_load_elim_ossa.sil
diff --git a/test/embedded/cxx-import-reference.swift b/test/embedded/cxx-import-reference.swift

Original file line number	Diff line number	Diff line change
`@@ -122,6 +122,8 @@ private func insertEndInitInstructions(`
`122`	`122`	`use.set(to: ssaUpdater.getValue(atEndOf: use.instruction.parentBlock), context)`
`123`	`123`	`}`
`124`	`124`	`}`
	`125`	`+ // This peephole optimization is required to avoid ownership errors.`
	`126`	`+ replacePhisWithIncomingValues(phis: ssaUpdater.insertedPhis, context)`
`125`	`127`	`}`
`126`	`128`
`127`	`129`	`private func constructLetInitRegion(`
Original file line number	Diff line number	Diff line change
`@@ -122,7 +122,8 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu`
`122`	`122`	`}`
`123`	`123`	`}`
`124`	`124`	`case let metatype as MetatypeInst:`
`125`		`- if context.options.enableEmbeddedSwift {`
	`125`	`+ if context.options.enableEmbeddedSwift,`
	`126`	`+ metatype.type.representationOfMetatype == .thick {`
`126`	`127`	`let instanceType = metatype.type.loweredInstanceTypeOfMetatype(in: function)`
`127`	`128`	`if instanceType.isClass {`
`128`	`129`	`specializeVTable(forClassType: instanceType, errorLocation: metatype.location, moduleContext) {`
Original file line number	Diff line number	Diff line change
`@@ -640,7 +640,7 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,`
`640`	`640`	`}`
`641`	`641`
`642`	`642`	`// Indirect arguments cannot escape the function, but loaded values from such can.`
`643`		`- if !followLoads(at: path) {`
	`643`	`+ if argOp.value.type.isAddress && !followLoads(at: path) {`
`644`	`644`	`if let beginApply = apply as? BeginApplyInst {`
`645`	`645`	`// begin_apply can yield an address value.`
`646`	`646`	`if !indirectResultEscapes(of: beginApply, path: path) {`
Original file line number	Diff line number	Diff line change
`@@ -975,6 +975,8 @@ extension LifetimeDependenceDefUseWalker {`
`975`	`975`	`return yieldedDependence(result: localAccess.operand!)`
`976`	`976`	`case .incomingArgument:`
`977`	`977`	`fatalError("Incoming arguments are never reachable")`
	`978`	`+ case .deadEnd:`
	`979`	`+ return .continueWalk`
`978`	`980`	`}`
`979`	`981`	`}`
`980`	`982`