Merge pull request #76231 from kubamracek/embedded-deinit-release

[embedded] Handle retain/retain ops inside deinit in Embedded Swift's swift_release

Author: kubamracek

stdlib/public/core/EmbeddedRuntime.swift

@@ -291,6 +291,17 @@ func swift_release_n_(object: UnsafeMutablePointer<HeapObject>?, n: UInt32) {
 
   let resultingRefcount = subFetchAcquireRelease(refcount, n: Int(n)) & HeapObject.refcountMask
   if resultingRefcount == 0 {
+    // Set the refcount to immortalRefCount before calling the object destroyer
+    // to prevent future retains/releases from having any effect. Unlike the
+    // full Swift runtime, we don't track the refcount inside deinit, so we
+    // won't be able to detect escapes or over-releases of `self` in deinit. We
+    // might want to reconsider that in the future.
+    //
+    // There can only be one thread with a reference at this point (because
+    // we're releasing the last existing reference), so a relaxed store is
+    // enough.
+    storeRelaxed(refcount, newValue: HeapObject.immortalRefCount)
+
     _swift_embedded_invoke_heap_object_destroy(object)
   } else if resultingRefcount < 0 {
     fatalError("negative refcount")
@@ -344,6 +355,9 @@ fileprivate func storeRelease(_ atomic: UnsafeMutablePointer<Int>, newValue: Int
   Builtin.atomicstore_release_Word(atomic._rawValue, newValue._builtinWordValue)
 }
 
+fileprivate func storeRelaxed(_ atomic: UnsafeMutablePointer<Int>, newValue: Int) {
+  Builtin.atomicstore_monotonic_Word(atomic._rawValue, newValue._builtinWordValue)
+}
 
 /// Exclusivity checking
 

test/embedded/deinit-release.swift

@@ -0,0 +1,26 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -enable-experimental-feature Embedded -O -c -o %t/main.o
+// RUN: %target-clang %t/main.o -o %t/a.out -dead_strip
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx || OS=linux-gnu
+
+class C {}
+
+struct Foo {
+    let foo: C = C()
+    let bar: C = C()
+}
+
+class Bar {}
+class SubBar: Bar {
+    var qwe = Foo()
+}
+
+var bar: SubBar? = SubBar()
+bar = nil
+print("OK!")
+
+// CHECK: OK!

test/embedded/deinit-release2.swift

@@ -0,0 +1,35 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s -enable-experimental-feature Embedded -O -c -o %t/main.o
+// RUN: %target-clang %t/main.o -o %t/a.out -dead_strip
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: swift_in_compiler
+// REQUIRES: executable_test
+// REQUIRES: OS=macosx || OS=linux-gnu
+
+public var global_c: C? = nil
+
+@inline(never) func opaque() { print(global_c == nil ? "global is nil" : "global is not nil") }
+
+public class C {
+    init() { print("init") }
+    deinit {
+        print("deinit")
+        global_c = self
+        opaque()
+        global_c = nil
+        opaque()
+        print("end of deinit")
+    }
+}
+
+var bar: C? = C()
+bar = nil
+print("OK!")
+
+// CHECK: init
+// CHECK: deinit
+// CHECK: global is not nil
+// CHECK: global is nil
+// CHECK: end of deinit
+// CHECK: OK!