TempLValueElimination: don't propagate alloc_stack which have access scopes

If exclusivity is checked for the alloc_stack we must not replace it with the copy-destination.
If the copy-destination is also in an access-scope this would result in an exclusivity violation which was not there before.

Fixes a miscompile which results in a wrong exclusivity violation error at runtime.
#83924
rdar://159220436

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/TempLValueElimination.swift

@@ -113,6 +113,13 @@ private func tryEliminate(copy: CopyLikeInstruction, _ context: FunctionPassCont
     return
   }
 
+  // If exclusivity is checked for the alloc_stack we must not replace it with the copy-destination.
+  // If the copy-destination is also in an access-scope this would result in an exclusivity violation
+  // which was not there before.
+  guard allocStack.uses.users(ofType: BeginAccessInst.self).isEmpty else {
+    return
+  }
+
   var worklist = InstructionWorklist(context)
   defer { worklist.deinitialize() }
   worklist.pushIfNotVisited(firstUseOfAllocStack)

test/SILOptimizer/templvalueopt_and_exclusivity.swift

@@ -0,0 +1,68 @@
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-build-swift %t/module.swift -parse-as-library -O -enable-library-evolution -module-name=Module -emit-module -emit-module-path %t/Module.swiftmodule
+// RUN: %target-build-swift %t/module.swift -parse-as-library -O -enable-library-evolution -module-name=Module -c -o %t/module.o
+// RUN: %target-build-swift -parse-as-library -O %t/main.swift -I%t %t/module.o -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: executable_test
+
+
+// Check that TempLValueElimination does not cause an exclusivity violation at runtime.
+
+//--- module.swift
+
+public struct ResilientStruct {
+  public init() {}
+}
+
+//--- main.swift
+
+import Module
+
+struct MyState {
+  var _prop: String
+  var prop: String
+  {
+    @storageRestrictions(initializes: _prop)
+    init(initialValue) {
+      _prop = initialValue
+    }
+    get {
+      return _prop
+    }
+  }
+
+  let resilient = ResilientStruct()
+
+  init(prop: String) {
+    self.prop = prop
+  }
+}
+
+class Node {
+  var state = MyState(prop: "initial value")
+
+  func update(_ body: (inout MyState) -> Void) {
+    body(&state)
+  }
+}
+
+@inline(never)
+func test_exclusivity() {
+  let node = Node()
+  node.update { state in
+    state = MyState(prop: "new value")
+  }
+}
+
+@main
+enum App {
+  static func main() {
+    test_exclusivity()
+    // CHECK: success
+    print("success")
+  }
+}

test/SILOptimizer/templvalueopt_ossa.sil

@@ -685,3 +685,20 @@ bb2:
   %r = tuple ()
   return %r
 }
+
+// CHECK-LABEL: sil [ossa] @dont_propagate_with_access_scope :
+// CHECK:         alloc_stack
+// CHECK:         copy_addr
+// CHECK-LABEL: } // end sil function 'dont_propagate_with_access_scope'
+sil [ossa] @dont_propagate_with_access_scope : $@convention(thin) (@inout Int, Int) -> () {
+bb0(%0 : $*Int, %1 : $Int):
+  %2 = alloc_stack $Int
+  %3 = begin_access [modify] [dynamic] %2
+  store %1 to [trivial] %3
+  end_access %3
+  copy_addr %2 to %0
+  dealloc_stack %2
+  %8 = tuple ()
+  return %8
+}
+