[embedded] Expand embedded runtime to handle stack promoted refcounted objects

Author: kubamracek

stdlib/public/core/EmbeddedRuntime.swift

@@ -28,6 +28,14 @@ public struct HeapObject {
   // to think about supporting (or banning) weak and/or unowned references.
   var refcount: Int
 
+#if _pointerBitWidth(_64)
+  static let doNotFreeBit = Int(bitPattern: 0x8000_0000_0000_0000)
+  static let refcountMask = Int(bitPattern: 0x7fff_ffff_ffff_ffff)
+#else
+  static let doNotFreeBit = Int(bitPattern: 0x8000_0000)
+  static let refcountMask = Int(bitPattern: 0x7fff_ffff)
+#endif
+
   static let immortalRefCount = -1
 }
 
@@ -65,18 +73,24 @@ public func swift_allocObject(metadata: UnsafeMutablePointer<ClassMetadata>, req
 
 @_silgen_name("swift_deallocClassInstance")
 public func swift_deallocClassInstance(object: UnsafeMutablePointer<HeapObject>, allocatedSize: Int, allocatedAlignMask: Int) {
+  if (object.pointee.refcount & HeapObject.doNotFreeBit) != 0 {
+    return
+  }
+
   free(object)
 }
 
 @_silgen_name("swift_initStackObject")
 public func swift_initStackObject(metadata: UnsafeMutablePointer<ClassMetadata>, object: UnsafeMutablePointer<HeapObject>) -> UnsafeMutablePointer<HeapObject> {
   object.pointee.metadata = metadata
-
-  // TODO/FIXME: Making all stack promoted objects immortal is not correct.
-  object.pointee.refcount = HeapObject.immortalRefCount
+  object.pointee.refcount = 1 | HeapObject.doNotFreeBit
   return object
 }
 
+@_silgen_name("swift_setDeallocating")
+public func swift_setDeallocating(object: UnsafeMutablePointer<HeapObject>) {
+}
+
 // TODO/FIXME: Refcounting and swift_once is not thread-safe, the following only works in single-threaded environments.
 
 @_silgen_name("swift_isUniquelyReferenced_nonNull_native")
@@ -102,7 +116,7 @@ public func swift_release(object: Builtin.RawPointer) {
   // TODO/FIXME: Refcounting is not thread-safe, the following only works in single-threaded environments.
   if o.pointee.refcount == HeapObject.immortalRefCount { return }
   o.pointee.refcount -= 1
-  if o.pointee.refcount == 0 {
+  if (o.pointee.refcount & HeapObject.refcountMask) == 0 {
     _swift_runtime_invoke_heap_object_destroy(o.pointee.metadata.pointee.destroy, o)
   }
 }

test/embedded/classes-stack-promotion.swift

@@ -0,0 +1,99 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -O -Xllvm -sil-disable-pass=function-signature-opts %s %S/Inputs/print.swift -enable-experimental-feature Embedded -module-name main -emit-irgen | %FileCheck %s --check-prefix CHECK-IR
+// RUN: %target-swift-frontend -O -Xllvm -sil-disable-pass=function-signature-opts %s %S/Inputs/print.swift -enable-experimental-feature Embedded -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: executable_test
+// REQUIRES: optimized_stdlib
+// REQUIRES: VENDOR=apple
+// REQUIRES: OS=macosx
+
+public class MyClass {
+  public init() { print("MyClass.init") }
+  deinit { print("MyClass.deinit") }
+  public func foo() { print("MyClass.foo") }
+}
+
+public class MySubClass: MyClass {
+  public override init() { print("MySubClass.init") }
+  deinit { print("MySubClass.deinit") }
+  public override func foo() { print("MySubClass.foo") }
+}
+
+@inline(never)
+public func bar(o: MyClass) {
+  o.foo()
+}
+
+final public class MyFinalClass {
+  public init() { print("MyFinalClass.init") }
+  deinit { print("MyFinalClass.deinit") }
+  public func foo() { print("MyFinalClass.foo") }
+}
+
+public struct MyStruct {
+  @inline(never)
+  init(_ c: MyFinalClass) {
+    c.foo()
+  }
+}
+
+@main
+struct Main {
+  static func test1() {
+    let o = MySubClass()
+    // CHECK: MySubClass.init
+    // CHECK: MyClass.init
+    o.foo()
+    // CHECK: MySubClass.foo
+    bar(o: o)
+    // CHECK: MySubClass.foo
+    // CHECK: MySubClass.deinit
+    // CHECK: MyClass.deinit
+  }
+
+  static func test2() -> MyStruct {
+    let c = MyFinalClass()
+    // CHECK: MyFinalClass.init
+    return MyStruct(c)
+    // CHECK: MyFinalClass.foo
+    // CHECK: MyFinalClass.deinit
+  }
+
+  static func main() {
+    test1()
+    print("")
+    test2()
+  }
+}
+
+// Check that stack promotion did really happen
+
+// CHECK-IR:      define {{.*}}@"$s4main8MyStructVyAcA0B10FinalClassCcfC"
+// CHECK-IR-NEXT: entry:
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main5print_10terminatorys12StaticStringV_AEtF"
+// CHECK-IR-NEXT:   call {{.*}}@swift_release
+// CHECK-IR-NEXT:   ret void
+// CHECK-IR-NEXT: }
+
+// CHECK-IR:      define {{.*}}@main
+// CHECK-IR-NEXT: entry:
+// CHECK-IR-NEXT:   alloca %T4main10MySubClassC
+// CHECK-IR-NEXT:   alloca %T4main12MyFinalClassC
+// CHECK-IR-NEXT:   call {{.*}}@swift_initStackObject
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main5print_10terminatorys12StaticStringV_AEtF"
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main5print_10terminatorys12StaticStringV_AEtF"
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main5print_10terminatorys12StaticStringV_AEtF"
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main3bar1oyAA7MyClassC_tF"
+// CHECK-IR-NEXT:   call {{.*}}@swift_setDeallocating
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main5print_10terminatorys12StaticStringV_AEtF"
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main5print_10terminatorys12StaticStringV_AEtF"
+// CHECK-IR-NEXT:   call {{.*}}@llvm.lifetime.end.p0
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main5print_10terminatorys12StaticStringV_AEtF"
+// CHECK-IR-NEXT:   call {{.*}}@swift_initStackObject
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main5print_10terminatorys12StaticStringV_AEtF"
+// CHECK-IR-NEXT:   call {{.*}}@"$s4main8MyStructVyAcA0B10FinalClassCcfC"
+// CHECK-IR-NEXT:   call {{.*}}@llvm.lifetime.end.p0
+// CHECK-IR-NEXT:   ret {{.*}}0
+// CHECK-IR-NEXT: }