Merge pull request #265 from swiftwasm/katei/embedded-followup

kateinoigakukun · web-flow · commit b78f3ca8215a · 2024-10-15T12:01:20.000+09:00
Follow-up adjustment for Embedded support
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -86,3 +86,19 @@ jobs:
       - run: swift build
         env:
           DEVELOPER_DIR: /Applications/${{ matrix.xcode }}.app/Contents/Developer/
+
+  embedded-build:
+    name: Build for embedded target
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        entry:
+          - os: ubuntu-22.04
+            toolchain: DEVELOPMENT-SNAPSHOT-2024-09-25-a
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/install-swift
+        with:
+          swift-dir: development/ubuntu2204
+          swift-version: swift-${{ matrix.entry.toolchain }}
+      - run: ./Examples/Embedded/build.sh
diff --git a/Examples/Embedded/Package.swift b/Examples/Embedded/Package.swift
@@ -6,14 +6,31 @@ let package = Package(
     name: "Embedded",
     dependencies: [
         .package(name: "JavaScriptKit", path: "../../"),
-        .package(url: "https://github.com/swifweb/EmbeddedFoundation", branch: "0.1.0")
+        .package(url: "https://github.com/swiftwasm/swift-dlmalloc", branch: "0.1.0")
     ],
     targets: [
         .executableTarget(
             name: "EmbeddedApp",
             dependencies: [
                 "JavaScriptKit",
-                .product(name: "Foundation", package: "EmbeddedFoundation")
+                .product(name: "dlmalloc", package: "swift-dlmalloc")
+            ],
+            cSettings: [
+                .unsafeFlags(["-fdeclspec"])
+            ],
+            swiftSettings: [
+                .enableExperimentalFeature("Embedded"),
+                .enableExperimentalFeature("Extern"),
+                .unsafeFlags([
+                    "-Xfrontend", "-gnone",
+                    "-Xfrontend", "-disable-stack-protector",
+                ]),
+            ],
+            linkerSettings: [
+                .unsafeFlags([
+                    "-Xclang-linker", "-nostdlib",
+                    "-Xlinker", "--no-entry"
+                ])
             ]
         )
     ]
diff --git a/Examples/Embedded/Sources/EmbeddedApp/_thingsThatShouldNotBeNeeded.swift b/Examples/Embedded/Sources/EmbeddedApp/_thingsThatShouldNotBeNeeded.swift
@@ -17,13 +17,9 @@ func strlen(_ s: UnsafePointer<Int8>) -> Int {
     return p - s
 }
 
-// TODO: why do I need this? and surely this is not ideal... figure this out, or at least have this come from a C lib
-@_cdecl("memmove")
-func memmove(_ dest: UnsafeMutableRawPointer, _ src: UnsafeRawPointer, _ n: Int) -> UnsafeMutableRawPointer {
-    let d = dest.assumingMemoryBound(to: UInt8.self)
-    let s = src.assumingMemoryBound(to: UInt8.self)
-    for i in 0..<n {
-        d[i] = s[i]
+@_cdecl("arc4random_buf")
+public func arc4random_buf(_ buffer: UnsafeMutableRawPointer, _ size: Int) {
+    for i in 0..<size {
+        buffer.storeBytes(of: UInt8.random(in: 0...255), toByteOffset: i, as: UInt8.self)
     }
-    return dest
-}
+}
diff --git a/Examples/Embedded/build.sh b/Examples/Embedded/build.sh
@@ -1,12 +1,10 @@
-EXPERIMENTAL_EMBEDDED_WASM=true swift build -c release --product EmbeddedApp \
+#!/bin/bash
+package_dir="$(cd "$(dirname "$0")" && pwd)"
+JAVASCRIPTKIT_EXPERIMENTAL_EMBEDDED_WASM=true swift build --package-path "$package_dir" -c release --product EmbeddedApp \
   --triple wasm32-unknown-none-wasm  \
   -Xswiftc -enable-experimental-feature -Xswiftc Embedded \
   -Xswiftc -enable-experimental-feature -Xswiftc Extern \
-  -Xswiftc -wmo -Xswiftc -disable-cmo \
-  -Xswiftc -Xfrontend -Xswiftc -gnone \
-  -Xswiftc -Xfrontend -Xswiftc -disable-stack-protector \
-  -Xswiftc -cxx-interoperability-mode=default \
   -Xcc -D__Embedded -Xcc -fdeclspec \
   -Xlinker --export-if-defined=__main_argc_argv \
   -Xlinker --export-if-defined=swjs_call_host_function \
-  -Xswiftc -Xclang-linker -Xswiftc -mexec-model=reactor
+  -Xswiftc -Xclang-linker -Xswiftc -mexec-model=reactor
diff --git a/Package.swift b/Package.swift
@@ -4,7 +4,7 @@ import PackageDescription
 import Foundation
 
 // NOTE: needed for embedded customizations, ideally this will not be necessary at all in the future, or can be replaced with traits
-let shouldBuildForEmbedded = ProcessInfo.processInfo.environment["EXPERIMENTAL_EMBEDDED_WASM"].flatMap(Bool.init) ?? false
+let shouldBuildForEmbedded = ProcessInfo.processInfo.environment["JAVASCRIPTKIT_EXPERIMENTAL_EMBEDDED_WASM"].flatMap(Bool.init) ?? false
 
 let package = Package(
     name: "JavaScriptKit",
diff --git a/Sources/JavaScriptKit/ConstructibleFromJSValue.swift b/Sources/JavaScriptKit/ConstructibleFromJSValue.swift
@@ -40,7 +40,7 @@ extension SignedInteger where Self: ConstructibleFromJSValue {
     /// If the value is too large to fit in the `Self` type, `nil` is returned.
     ///
     /// - Parameter bigInt: The `JSBigIntExtended` to decode
-    public init?(exactly bigInt: JSBigIntExtended) {
+    public init?(exactly bigInt: some JSBigIntExtended) {
         self.init(exactly: bigInt.int64Value)
     }
 
@@ -49,7 +49,7 @@ extension SignedInteger where Self: ConstructibleFromJSValue {
     /// Crash if the value is too large to fit in the `Self` type.
     ///
     /// - Parameter bigInt: The `JSBigIntExtended` to decode
-    public init(_ bigInt: JSBigIntExtended) {
+    public init(_ bigInt: some JSBigIntExtended) {
         self.init(bigInt.int64Value)
     }
 
@@ -68,9 +68,11 @@ extension SignedInteger where Self: ConstructibleFromJSValue {
         if let number = value.number {
             return Self(exactly: number.rounded(.towardZero))
         }
+#if !hasFeature(Embedded)
         if let bigInt = value.bigInt as? JSBigIntExtended {
             return Self(exactly: bigInt)
         }
+#endif
         return nil
     }
 }
@@ -87,7 +89,7 @@ extension UnsignedInteger where Self: ConstructibleFromJSValue {
     /// Returns `nil` if the value is negative or too large to fit in the `Self` type.
     ///
     /// - Parameter bigInt: The `JSBigIntExtended` to decode
-    public init?(exactly bigInt: JSBigIntExtended) {
+    public init?(exactly bigInt: some JSBigIntExtended) {
         self.init(exactly: bigInt.uInt64Value)
     }
 
@@ -96,7 +98,7 @@ extension UnsignedInteger where Self: ConstructibleFromJSValue {
     /// Crash if the value is negative or too large to fit in the `Self` type.
     ///
     /// - Parameter bigInt: The `JSBigIntExtended` to decode
-    public init(_ bigInt: JSBigIntExtended) {
+    public init(_ bigInt: some JSBigIntExtended) {
         self.init(bigInt.uInt64Value)
     }
 
@@ -114,9 +116,11 @@ extension UnsignedInteger where Self: ConstructibleFromJSValue {
         if let number = value.number {
             return Self(exactly: number.rounded(.towardZero))
         }
+#if !hasFeature(Embedded)
         if let bigInt = value.bigInt as? JSBigIntExtended {
             return Self(exactly: bigInt)
         }
+#endif
         return nil
     }
 }
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift b/Sources/JavaScriptKit/FundamentalObjects/JSFunction.swift
@@ -136,7 +136,7 @@ public class JSFunction: JSObject, _JSFunctionProtocol {
                 id, argv, Int32(argc),
                 &payload1, &payload2
             )
-            let kindAndFlags = valueKindAndFlagsFromBits(resultBitPattern)
+            let kindAndFlags = JavaScriptValueKindAndFlags(bitPattern: resultBitPattern)
             assert(!kindAndFlags.isException)
             let result = RawJSValue(kind: kindAndFlags.kind, payload1: payload1, payload2: payload2)
             return result
@@ -153,7 +153,7 @@ public class JSFunction: JSObject, _JSFunctionProtocol {
                 id, argv, Int32(argc),
                 &payload1, &payload2
             )
-            let kindAndFlags = valueKindAndFlagsFromBits(resultBitPattern)
+            let kindAndFlags = JavaScriptValueKindAndFlags(bitPattern: resultBitPattern)
             #if !hasFeature(Embedded)
             assert(!kindAndFlags.isException)
             #endif
@@ -241,25 +241,15 @@ public extension _JSFunctionProtocol {
         new(arguments: [arg0.jsValue, arg1.jsValue, arg2.jsValue, arg3.jsValue, arg4.jsValue, arg5.jsValue, arg6.jsValue])
     }
 }
+#endif
 
-// C bit fields seem to not work with Embedded
-// in "normal mode" this is defined as a C struct
-private struct JavaScriptValueKindAndFlags {
-    let errorBit: UInt32 = 1 << 32
+internal struct JavaScriptValueKindAndFlags {
+    static var errorBit: UInt32 { 1 << 31 }
     let kind: JavaScriptValueKind
     let isException: Bool
 
     init(bitPattern: UInt32) {
-        self.kind = JavaScriptValueKind(rawValue: bitPattern & ~errorBit)!
-        self.isException = (bitPattern & errorBit) != 0
+        self.kind = JavaScriptValueKind(rawValue: bitPattern & ~Self.errorBit)!
+        self.isException = (bitPattern & Self.errorBit) != 0
     }
 }
-#endif
-
-private func valueKindAndFlagsFromBits(_ bits: UInt32) -> JavaScriptValueKindAndFlags {
-    #if hasFeature(Embedded)
-    JavaScriptValueKindAndFlags(bitPattern: bits)
-    #else 
-    unsafeBitCast(bits, to: JavaScriptValueKindAndFlags.self)
-    #endif
-}
diff --git a/Sources/JavaScriptKit/FundamentalObjects/JSThrowingFunction.swift b/Sources/JavaScriptKit/FundamentalObjects/JSThrowingFunction.swift
@@ -42,13 +42,14 @@ public class JSThrowingFunction {
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
 
-                var exceptionKind = JavaScriptValueKindAndFlags()
+                var exceptionRawKind = JavaScriptRawValueKindAndFlags()
                 var exceptionPayload1 = JavaScriptPayload1()
                 var exceptionPayload2 = JavaScriptPayload2()
                 let resultObj = swjs_call_throwing_new(
                     self.base.id, argv, Int32(argc),
-                    &exceptionKind, &exceptionPayload1, &exceptionPayload2
+                    &exceptionRawKind, &exceptionPayload1, &exceptionPayload2
                 )
+                let exceptionKind = JavaScriptValueKindAndFlags(bitPattern: exceptionRawKind)
                 if exceptionKind.isException {
                     let exception = RawJSValue(kind: exceptionKind.kind, payload1: exceptionPayload1, payload2: exceptionPayload2)
                     return .failure(exception.jsValue)
@@ -70,21 +71,21 @@ private func invokeJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSV
         rawValues.withUnsafeBufferPointer { bufferPointer -> (JSValue, Bool) in
             let argv = bufferPointer.baseAddress
             let argc = bufferPointer.count
-            var kindAndFlags = JavaScriptValueKindAndFlags()
+            let kindAndFlags: JavaScriptValueKindAndFlags
             var payload1 = JavaScriptPayload1()
             var payload2 = JavaScriptPayload2()
             if let thisId = this?.id {
                 let resultBitPattern = swjs_call_function_with_this(
                     thisId, id, argv, Int32(argc),
                     &payload1, &payload2
                 )
-                kindAndFlags = unsafeBitCast(resultBitPattern, to: JavaScriptValueKindAndFlags.self)
+                kindAndFlags = JavaScriptValueKindAndFlags(bitPattern: resultBitPattern)
             } else {
                 let resultBitPattern = swjs_call_function(
                     id, argv, Int32(argc),
                     &payload1, &payload2
                 )
-                kindAndFlags = unsafeBitCast(resultBitPattern, to: JavaScriptValueKindAndFlags.self)
+                kindAndFlags = JavaScriptValueKindAndFlags(bitPattern: resultBitPattern)
             }
             let result = RawJSValue(kind: kindAndFlags.kind, payload1: payload1, payload2: payload2)
             return (result.jsValue, kindAndFlags.isException)
@@ -95,4 +96,4 @@ private func invokeJSFunction(_ jsFunc: JSFunction, arguments: [ConvertibleToJSV
     }
     return result
 }
-#endif
+#endif
diff --git a/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h b/Sources/_CJavaScriptKit/include/_CJavaScriptKit.h
@@ -29,15 +29,7 @@ typedef enum __attribute__((enum_extensibility(closed))) {
   JavaScriptValueKindBigInt = 8,
 } JavaScriptValueKind;
 
-#if __Embedded
-// something about the bit field widths is not working with embedded
-typedef unsigned short JavaScriptValueKindAndFlags;
-#else
-typedef struct {
-  JavaScriptValueKind kind: 31;
-  bool isException: 1;
-} JavaScriptValueKindAndFlags;
-#endif
+typedef uint32_t JavaScriptRawValueKindAndFlags;
 
 typedef unsigned JavaScriptPayload1;
 typedef double JavaScriptPayload2;
@@ -253,7 +245,7 @@ IMPORT_JS_FUNCTION(swjs_call_new, JavaScriptObjectRef, (const JavaScriptObjectRe
 IMPORT_JS_FUNCTION(swjs_call_throwing_new, JavaScriptObjectRef, (const JavaScriptObjectRef ref,
                                                                  const RawJSValue *argv,
                                                                  const int argc,
-                                                                 JavaScriptValueKindAndFlags *exception_kind,
+                                                                 JavaScriptRawValueKindAndFlags *exception_kind,
                                                                  JavaScriptPayload1 *exception_payload1,
                                                                  JavaScriptPayload2 *exception_payload2))
 

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ extension SignedInteger where Self: ConstructibleFromJSValue {`
`40`	`40`	/// If the value is too large to fit in the `Self` type, `nil` is returned.
`41`	`41`	`///`
`42`	`42`	/// - Parameter bigInt: The `JSBigIntExtended` to decode
`43`		`- public init?(exactly bigInt: JSBigIntExtended) {`
	`43`	`+ public init?(exactly bigInt: some JSBigIntExtended) {`
`44`	`44`	`self.init(exactly: bigInt.int64Value)`
`45`	`45`	`}`
`46`	`46`
`@@ -49,7 +49,7 @@ extension SignedInteger where Self: ConstructibleFromJSValue {`
`49`	`49`	/// Crash if the value is too large to fit in the `Self` type.
`50`	`50`	`///`
`51`	`51`	/// - Parameter bigInt: The `JSBigIntExtended` to decode
`52`		`- public init(_ bigInt: JSBigIntExtended) {`
	`52`	`+ public init(_ bigInt: some JSBigIntExtended) {`
`53`	`53`	`self.init(bigInt.int64Value)`
`54`	`54`	`}`
`55`	`55`
`@@ -68,9 +68,11 @@ extension SignedInteger where Self: ConstructibleFromJSValue {`
`68`	`68`	`if let number = value.number {`
`69`	`69`	`return Self(exactly: number.rounded(.towardZero))`
`70`	`70`	`}`
	`71`	`+#if !hasFeature(Embedded)`
`71`	`72`	`if let bigInt = value.bigInt as? JSBigIntExtended {`
`72`	`73`	`return Self(exactly: bigInt)`
`73`	`74`	`}`
	`75`	`+#endif`
`74`	`76`	`return nil`
`75`	`77`	`}`
`76`	`78`	`}`
`@@ -87,7 +89,7 @@ extension UnsignedInteger where Self: ConstructibleFromJSValue {`
`87`	`89`	/// Returns `nil` if the value is negative or too large to fit in the `Self` type.
`88`	`90`	`///`
`89`	`91`	/// - Parameter bigInt: The `JSBigIntExtended` to decode
`90`		`- public init?(exactly bigInt: JSBigIntExtended) {`
	`92`	`+ public init?(exactly bigInt: some JSBigIntExtended) {`
`91`	`93`	`self.init(exactly: bigInt.uInt64Value)`
`92`	`94`	`}`
`93`	`95`
`@@ -96,7 +98,7 @@ extension UnsignedInteger where Self: ConstructibleFromJSValue {`
`96`	`98`	/// Crash if the value is negative or too large to fit in the `Self` type.
`97`	`99`	`///`
`98`	`100`	/// - Parameter bigInt: The `JSBigIntExtended` to decode
`99`		`- public init(_ bigInt: JSBigIntExtended) {`
	`101`	`+ public init(_ bigInt: some JSBigIntExtended) {`
`100`	`102`	`self.init(bigInt.uInt64Value)`
`101`	`103`	`}`
`102`	`104`
`@@ -114,9 +116,11 @@ extension UnsignedInteger where Self: ConstructibleFromJSValue {`
`114`	`116`	`if let number = value.number {`
`115`	`117`	`return Self(exactly: number.rounded(.towardZero))`
`116`	`118`	`}`
	`119`	`+#if !hasFeature(Embedded)`
`117`	`120`	`if let bigInt = value.bigInt as? JSBigIntExtended {`
`118`	`121`	`return Self(exactly: bigInt)`
`119`	`122`	`}`
	`123`	`+#endif`
`120`	`124`	`return nil`
`121`	`125`	`}`
`122`	`126`	`}`