[embedded] Add a simple Swift runtime, written in embedded Swift

kubamracek · kubamracek · commit 179136f3c931 · 2023-09-24T12:36:02.000-07:00
diff --git a/lib/SILOptimizer/UtilityPasses/Link.cpp b/lib/SILOptimizer/UtilityPasses/Link.cpp
@@ -13,6 +13,7 @@
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
 #include "swift/SIL/SILModule.h"
+#include "swift/Serialization/SerializedSILLoader.h"
 
 using namespace swift;
 
@@ -35,8 +36,38 @@ class SILLinker : public SILModuleTransform {
     for (auto &Fn : M)
       if (M.linkFunction(&Fn, LinkMode))
         invalidateAnalysis(&Fn, SILAnalysis::InvalidationKind::Everything);
+
+    // In embedded Swift, the stdlib contains all the runtime functions needed
+    // (swift_retain, etc.). Link them in so they can be referenced in IRGen.
+    if (M.getASTContext().LangOpts.hasFeature(Feature::Embedded) &&
+        !M.isStdlibModule()) {
+      linkEmbeddedRuntimeFromStdlib();
+    }
+  }
+
+  void linkEmbeddedRuntimeFromStdlib() {
+    #define FUNCTION(ID, NAME, CC, AVAILABILITY, RETURNS, ARGS, ATTRS, EFFECT) \
+      linkEmbeddedRuntimeFunctionByName(#NAME);
+
+    #define RETURNS(...)
+    #define ARGS(...)
+    #define NO_ARGS
+    #define ATTRS(...)
+    #define NO_ATTRS
+    #define EFFECT(...)
+
+    #include "swift/Runtime/RuntimeFunctions.def"
   }
 
+  void linkEmbeddedRuntimeFunctionByName(StringRef name) {
+    SILModule &M = *getModule();
+    SILFunction *Fn =
+        M.getSILLoader()->lookupSILFunction(name, SILLinkage::PublicExternal);
+    if (!Fn) return;
+
+    if (M.linkFunction(Fn, LinkMode))
+      invalidateAnalysis(Fn, SILAnalysis::InvalidationKind::Everything);
+  }
 };
 } // end anonymous namespace
 
diff --git a/stdlib/public/SwiftShims/swift/shims/CMakeLists.txt b/stdlib/public/SwiftShims/swift/shims/CMakeLists.txt
@@ -1,6 +1,7 @@
 set(sources
   AssertionReporting.h
   CoreFoundationShims.h
+  EmbeddedShims.h
   FoundationShims.h
   GlobalObjects.h
   HeapObject.h
diff --git a/stdlib/public/SwiftShims/swift/shims/EmbeddedShims.h b/stdlib/public/SwiftShims/swift/shims/EmbeddedShims.h
@@ -0,0 +1,49 @@
+//===--- EmbeddedShims.h - shims for embedded Swift -------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+//  Shims for embedded Swift.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_STDLIB_SHIMS_EMBEDDEDSHIMS_H
+#define SWIFT_STDLIB_SHIMS_EMBEDDEDSHIMS_H
+
+#include "SwiftStddef.h"
+#include "Visibility.h"
+
+#if __has_feature(nullability)
+#pragma clang assume_nonnull begin
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SWIFT_CC __attribute__((swiftcall))
+#define SWIFT_CONTEXT __attribute__((swift_context))
+
+typedef void SWIFT_CC (*HeapObjectDestroyer)(SWIFT_CONTEXT void *object);
+
+static inline void _swift_runtime_invoke_heap_object_destroy(
+    const void *destroy, void *self) {
+  ((HeapObjectDestroyer)destroy)(self);
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#if __has_feature(nullability)
+#pragma clang assume_nonnull end
+#endif
+
+#endif // SWIFT_STDLIB_SHIMS_EMBEDDEDSHIMS_H
diff --git a/stdlib/public/SwiftShims/swift/shims/module.modulemap b/stdlib/public/SwiftShims/swift/shims/module.modulemap
@@ -1,6 +1,7 @@
 module SwiftShims {
   header "AssertionReporting.h"
   header "CoreFoundationShims.h"
+  header "EmbeddedShims.h"
   header "FoundationShims.h"
   header "GlobalObjects.h"
   header "HeapObject.h"
diff --git a/stdlib/public/core/CMakeLists.txt b/stdlib/public/core/CMakeLists.txt
@@ -254,7 +254,10 @@ if(SWIFT_STDLIB_ENABLE_VECTOR_TYPES)
   list(APPEND SWIFTLIB_GYB_SOURCES SIMDConcreteOperations.swift.gyb SIMDVectorTypes.swift.gyb)
 endif()
 
-list(APPEND SWIFTLIB_EMBEDDED_SOURCES EmbeddedStubs.swift)
+list(APPEND SWIFTLIB_EMBEDDED_SOURCES
+  EmbeddedRuntime.swift
+  EmbeddedStubs.swift
+  )
 
 set(GROUP_INFO_JSON_FILE ${CMAKE_CURRENT_SOURCE_DIR}/GroupInfo.json)
 set(swift_core_link_flags "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}")
@@ -426,6 +429,7 @@ if(SWIFT_SHOULD_BUILD_EMBEDDED_STDLIB)
       MODULE_DIR "${CMAKE_BINARY_DIR}/lib/swift/embedded"
       SDK "embedded"
       ARCHITECTURE "${arch}"
+      FILE_DEPENDS ${swiftCore_common_dependencies}
       INSTALL_IN_COMPONENT "never_install"
       )
     add_dependencies(embedded-stdlib embedded-stdlib-${triple})
diff --git a/stdlib/public/core/EmbeddedRuntime.swift b/stdlib/public/core/EmbeddedRuntime.swift
@@ -0,0 +1,121 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftShims
+
+public struct ClassMetadata {
+  var superclassMetadata: UnsafeMutablePointer<ClassMetadata>?
+
+  // There is no way to express the actual calling convention on the heap desroy
+  // function (swiftcc with 'self') currently, so let's use UnsafeRawPointer
+  // and a helper function in C (_swift_runtime_invoke_heap_object_destroy).
+  var destroy: UnsafeRawPointer
+}
+
+public struct HeapObject {
+  var metadata: UnsafeMutablePointer<ClassMetadata>
+  var refcount: Int
+}
+
+@_silgen_name("posix_memalign")
+func posix_memalign(_: UnsafeMutablePointer<UnsafeMutableRawPointer?>, _: UInt, _: UInt) -> CInt
+
+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
+}
+
+@_cdecl("swift_slowAlloc")
+public func swift_slowAlloc(_ size: UInt, _ alignMask: UInt) -> UnsafeMutableRawPointer? {
+  let alignment: UInt
+  if alignMask == UInt.max {
+    alignment = UInt(_swift_MinAllocationAlignment)
+  } else {
+    alignment = alignMask + 1
+  }
+  return alignedAlloc(size: size, alignment: alignment)
+}
+
+@_cdecl("swift_slowDealloc")
+public func swift_slowDealloc(_ ptr: UnsafeMutableRawPointer?, _ size: UInt, _ alignMask: UInt) {
+  free(ptr)
+}
+
+@_silgen_name("swift_allocObject")
+public func swift_allocObject(metadata: UnsafeMutablePointer<ClassMetadata>, 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: UnsafeMutablePointer<ClassMetadata>, object: UnsafeMutablePointer<HeapObject>) -> UnsafeMutablePointer<HeapObject> {
+  object.pointee.metadata = metadata
+  object.pointee.refcount = -1
+  return object
+}
+
+// TODO/FIXME: Refcounting and swift_once is not thread-safe, the following only works in single-threaded environments.
+
+@_silgen_name("swift_isUniquelyReferenced_nonNull_native")
+public func swift_isUniquelyReferenced_nonNull_native(object: UnsafeMutablePointer<HeapObject>) -> Bool {
+  // TODO/FIXME: Refcounting is not thread-safe, the following only works in single-threaded environments.
+  return object.pointee.refcount == 1
+}
+
+@_silgen_name("swift_retain")
+public func swift_retain(object: Builtin.RawPointer) -> Builtin.RawPointer {
+  if Int(Builtin.ptrtoint_Word(object)) == 0 { return object }
+  let o = UnsafeMutablePointer<HeapObject>(object)
+  // TODO/FIXME: Refcounting is not thread-safe, the following only works in single-threaded environments.
+  if o.pointee.refcount == -1 { return o._rawValue }
+  o.pointee.refcount += 1
+  return o._rawValue
+}
+
+@_silgen_name("swift_release")
+public func swift_release(object: Builtin.RawPointer) {
+  if Int(Builtin.ptrtoint_Word(object)) == 0 { return }
+  let o = UnsafeMutablePointer<HeapObject>(object)
+  // TODO/FIXME: Refcounting is not thread-safe, the following only works in single-threaded environments.
+  if o.pointee.refcount == -1 { return }
+  o.pointee.refcount -= 1
+  if o.pointee.refcount == 0 {
+    _swift_runtime_invoke_heap_object_destroy(o.pointee.metadata.pointee.destroy, o)
+  }
+}
+
+@_silgen_name("swift_beginAccess")
+public func swift_beginAccess(pointer: UnsafeMutableRawPointer, buffer: UnsafeMutableRawPointer, flags: UInt, pc: UnsafeMutableRawPointer) {
+}
+
+@_silgen_name("swift_endAccess")
+public func swift_endAccess(buffer: UnsafeMutableRawPointer) {
+}
+
+@_silgen_name("swift_once")
+public func swift_once(predicate: UnsafeMutablePointer<Int>, fn: (@convention(c) (UnsafeMutableRawPointer)->()), context: UnsafeMutableRawPointer) {
+  // TODO/FIXME: The following only works in single-threaded environments.
+  if predicate.pointee == 0 {
+    predicate.pointee = 1
+    fn(context)
+  }
+}
diff --git a/stdlib/public/core/GroupInfo.json b/stdlib/public/core/GroupInfo.json
@@ -244,6 +244,7 @@
     "Duration.swift",
     "DurationProtocol.swift",
     "Instant.swift",
+    "EmbeddedRuntime.swift",
     "EmbeddedStubs.swift"
   ],
   "Result": [
diff --git a/test/embedded/Inputs/tiny-runtime-dummy-refcounting.c b/test/embedded/Inputs/tiny-runtime-dummy-refcounting.c
diff --git a/test/embedded/array-to-pointer.swift b/test/embedded/array-to-pointer.swift
@@ -1,8 +1,7 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-swift-frontend %s -enable-experimental-feature Embedded -c -o %t/main.o
-// RUN: %target-clang -x c -c %S/Inputs/tiny-runtime-dummy-refcounting.c -o %t/runtime.o
 // RUN: %target-clang -x c -c %S/Inputs/print.c -o %t/print.o
-// RUN: %target-clang %t/main.o %t/runtime.o %t/print.o -o %t/a.out -dead_strip
+// 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
diff --git a/test/embedded/arrays.swift b/test/embedded/arrays.swift
@@ -1,8 +1,7 @@
 // RUN: %empty-directory(%t)
 // RUN: %target-swift-frontend %s -enable-experimental-feature Embedded -c -o %t/main.o
-// RUN: %target-clang -x c -c %S/Inputs/tiny-runtime-dummy-refcounting.c -o %t/runtime.o
 // RUN: %target-clang -x c -c %S/Inputs/print.c -o %t/print.o
-// RUN: %target-clang %t/main.o %t/runtime.o %t/print.o -o %t/a.out -dead_strip
+// 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
diff --git a/test/embedded/classes-arrays.swift b/test/embedded/classes-arrays.swift
@@ -1,7 +1,6 @@
 // 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 -x c -c %S/Inputs/tiny-runtime-dummy-refcounting.c -o %t/runtime.o
-// RUN: %target-clang %t/main.o %t/runtime.o -o %t/a.out -dead_strip
+// RUN: %target-clang %t/main.o -o %t/a.out -dead_strip
 // RUN: %target-run %t/a.out | %FileCheck %s
 
 // REQUIRES: executable_test
diff --git a/test/embedded/classes.swift b/test/embedded/classes.swift
@@ -1,7 +1,6 @@
 // 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 -x c -c %S/Inputs/tiny-runtime-dummy-refcounting.c -o %t/runtime.o
-// RUN: %target-clang %t/main.o %t/runtime.o -o %t/a.out -dead_strip
+// RUN: %target-clang %t/main.o -o %t/a.out -dead_strip
 // RUN: %target-run %t/a.out | %FileCheck %s
 
 // REQUIRES: executable_test
diff --git a/test/embedded/runtime.swift b/test/embedded/runtime.swift
