Merge pull request #68912 from kubamracek/embedded-closures-heap

[embedded] Support closures with captures and promoting locals to refcounted heap objects

Author: kubamracek

lib/Frontend/CompilerInvocation.cpp

@@ -3123,6 +3123,8 @@ bool CompilerInvocation::parseArgs(
   if (LangOpts.hasFeature(Feature::Embedded)) {
     IRGenOpts.InternalizeAtLink = true;
     IRGenOpts.DisableLegacyTypeInfo = true;
+    IRGenOpts.ReflectionMetadata = ReflectionMetadataMode::None;
+    IRGenOpts.EnableReflectionNames = false;
     SILOpts.CMOMode = CrossModuleOptimizationMode::Everything;
     SILOpts.EmbeddedSwift = true;
   }

lib/IRGen/GenHeap.cpp

@@ -499,6 +499,22 @@ static llvm::Constant *buildPrivateMetadata(IRGenModule &IGM,
                                             MetadataKind kind) {
   // Build the fields of the private metadata.
   ConstantInitBuilder builder(IGM);
+
+  // In embedded Swift, heap objects have a different, simple(r) layout:
+  // superclass pointer + destructor.
+  if (IGM.Context.LangOpts.hasFeature(Feature::Embedded)) {
+    auto fields = builder.beginStruct();
+    fields.addNullPointer(IGM.Int8PtrTy);
+    fields.addSignedPointer(dtorFn,
+                            IGM.getOptions().PointerAuth.HeapDestructors,
+                            PointerAuthEntity::Special::HeapDestructor);
+
+    llvm::GlobalVariable *var = fields.finishAndCreateGlobal(
+        "metadata", IGM.getPointerAlignment(), /*constant*/ true,
+        llvm::GlobalVariable::PrivateLinkage);
+    return var;
+  }
+
   auto fields = builder.beginStruct(IGM.FullBoxMetadataStructTy);
 
   fields.addSignedPointer(dtorFn, IGM.getOptions().PointerAuth.HeapDestructors,

stdlib/public/core/EmbeddedRuntime.swift

@@ -77,6 +77,11 @@ public func swift_allocObject(metadata: UnsafeMutablePointer<ClassMetadata>, req
   return object
 }
 
+@_silgen_name("swift_deallocObject")
+public func swift_deallocObject(object: UnsafeMutablePointer<HeapObject>, allocatedSize: Int, allocatedAlignMask: Int) {
+  free(object)
+}
+
 @_silgen_name("swift_deallocClassInstance")
 public func swift_deallocClassInstance(object: UnsafeMutablePointer<HeapObject>, allocatedSize: Int, allocatedAlignMask: Int) {
   if (object.pointee.refcount & HeapObject.doNotFreeBit) != 0 {

test/embedded/closures-heap.swift

@@ -0,0 +1,36 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %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 {
+  var handler: (()->())? = nil
+  func foo() {
+    handler?()
+  }
+  deinit { print("deinit") }
+}
+
+@main
+struct Main {
+  static var o: MyClass? = nil
+
+  static func main() {
+    o = MyClass()
+    o!.handler = { print("no captures") }
+    o!.foo() // CHECK: no captures
+    o = nil // CHECK: deinit
+
+    var local = 42
+    o = MyClass()
+    o!.handler = { print("capture local"); local += 1 }
+    o!.foo() // CHECK: capture local
+    print(local == 43 ? "43" : "???") // CHECK: 43
+    o = nil // CHECK: deinit
+  }
+}