[embedded] Add a test showcasing a small runtime handling refcounting and class allocations written in embedded Swift

Author: kubamracek

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -63,6 +63,11 @@ internal final class __EmptyArrayStorage
   }
 }
 
+#if $Embedded
+public var _swiftEmptyArrayStorage: (Int, Int, Int, Int) =
+    (/*isa*/0, /*refcount*/-1, /*count*/0, /*flags*/1)
+#endif
+
 /// The empty array prototype.  We use the same object for all empty
 /// `[Native]Array<Element>`s.
 @inlinable

test/embedded/Inputs/tiny-runtime-dummy-refcounting.c

@@ -3,8 +3,6 @@
 #include <stdlib.h>
 #include <stdbool.h>
 
-size_t _swiftEmptyArrayStorage[] = { /*isa*/0, /*refcount*/-1, /*count*/0, /*flags*/1 };
-
 typedef struct ClassMetadata ClassMetadata;
 typedef struct HeapObject HeapObject;
 

test/embedded/Inputs/tiny-runtime-dummy-refcounting.swift

@@ -0,0 +1,80 @@
+let _swift_MinAllocationAlignment: UInt = 16
+
+@_silgen_name("posix_memalign")
+func posix_memalign(_: UnsafeMutablePointer<UnsafeMutableRawPointer?>, _: UInt, _: UInt) -> CInt
+
+@_silgen_name("free")
+func free(_: UnsafeMutableRawPointer?)
+
+func alignedAlloc(size: UInt, alignment: UInt) -> UnsafeMutableRawPointer? {
+  let alignment = max(alignment, UInt(MemoryLayout<UnsafeRawPointer>.size))
+  var r: UnsafeMutableRawPointer? = nil
+  _ = posix_memalign(&r, alignment, size)
+  return r
+}
+
+/// Public APIs
+// void *swift_slowAlloc(size_t size, size_t alignMask);
+@_cdecl("swift_slowAlloc")
+public func swift_slowAlloc(_ size: UInt, _ alignMask: UInt) -> UnsafeMutableRawPointer? {
+  let alignment: UInt
+  if alignMask == UInt.max {
+    alignment = _swift_MinAllocationAlignment
+  } else {
+    alignment = alignMask + 1
+  }
+  return alignedAlloc(size: size, alignment: alignment)
+}
+
+// void swift_slowDealloc(void *ptr, size_t bytes, size_t alignMask);
+@_cdecl("swift_slowDealloc")
+public func swift_slowDealloc(_ ptr: UnsafeMutableRawPointer?, _ size: UInt, _ alignMask: UInt) {
+  free(ptr)
+}
+
+@_silgen_name("swift_allocObject")
+public func swift_allocObject(metadata: UnsafeMutableRawPointer, requiredSize: UInt, requiredAlignmentMask: UInt) -> UnsafeMutablePointer<HeapObject> {
+  let p = swift_slowAlloc(requiredSize, requiredAlignmentMask)!
+  let object = p.assumingMemoryBound(to: HeapObject.self)
+  object.pointee.metadata = metadata
+  object.pointee.refcount = 1
+  return object
+}
+
+@_silgen_name("swift_deallocClassInstance")
+public func swift_deallocClassInstance(object: UnsafeMutablePointer<HeapObject>, allocatedSize: UInt, allocatedAlignMask: UInt) {
+  free(object)
+}
+
+@_silgen_name("swift_initStackObject")
+public func swift_initStackObject(metadata: UnsafeMutableRawPointer, object: UnsafeMutablePointer<HeapObject>) -> UnsafeMutablePointer<HeapObject> {
+  object.pointee.metadata = metadata
+  object.pointee.refcount = -1
+  return object
+}
+
+@_silgen_name("swift_isUniquelyReferenced_nonNull_native")
+public func swift_isUniquelyReferenced_nonNull_native(object: UnsafeMutablePointer<HeapObject>) -> Bool {
+  return object.pointee.refcount == 1
+}
+
+public struct HeapObject {
+  var metadata: UnsafeMutableRawPointer
+  var refcount: Int
+}
+
+@_silgen_name("swift_retain")
+public func swift_retain(object: UnsafeMutablePointer<HeapObject>) -> UnsafeMutablePointer<HeapObject> {
+  if object.pointee.refcount == -1 { return object }
+  object.pointee.refcount += 1
+  return object
+}
+
+@_silgen_name("swift_release")
+public func swift_release(object: UnsafeMutablePointer<HeapObject>) {
+  if object.pointee.refcount == -1 { return }
+  object.pointee.refcount -= 1
+  if object.pointee.refcount == 0 {
+    free(object)
+  }
+}

test/embedded/arrays-swift-runtime.swift

@@ -0,0 +1,60 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend %s %S/Inputs/tiny-runtime-dummy-refcounting.swift -enable-experimental-feature Embedded -c -o %t/main.o
+// RUN: %target-clang -x c -c %S/Inputs/print.c -o %t/print.o
+// RUN: %target-clang %t/main.o %t/print.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
+
+@_silgen_name("putchar")
+func putchar(_: UInt8)
+
+public func print(_ s: StaticString, terminator: StaticString = "\n") {
+  var p = s.utf8Start
+  while p.pointee != 0 {
+    putchar(p.pointee)
+    p += 1
+  }
+  p = terminator.utf8Start
+  while p.pointee != 0 {
+    putchar(p.pointee)
+    p += 1
+  }
+}
+
+@_silgen_name("print_long")
+func print_long(_: Int)
+
+public func print(_ n: Int, terminator: StaticString = "\n") {
+    print_long(n)
+    print("", terminator: terminator)
+}
+
+func print(_ array: [Int]) {
+    print("[", terminator: "")
+    for i in 0 ..< array.count {
+        print_long(array[i])
+        if i != array.count - 1 { print(", ", terminator: "") }
+    }
+    print("]")
+}
+
+func test() {
+  var a = [1, 2, 3]
+  a.append(8)
+  a.append(contentsOf: [5, 4])
+  let b = a.sorted()
+  var c = b
+  c = c.reversed().filter { $0 % 2 == 0 }
+  print(c) // CHECK: [8, 4, 2]
+}
+
+@main
+struct Main {
+  static func main() {
+    test()
+  }
+}