WITOverlayGenerator: Support Embedded target build

Author: kateinoigakukun

Package.swift

@@ -166,7 +166,7 @@ if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
         .testTarget(
             name: "WITOverlayGeneratorTests",
             dependencies: ["WITOverlayGenerator", "WasmKit", "WasmKitWASI"],
-            exclude: ["Fixtures", "Compiled", "Generated"],
+            exclude: ["Fixtures", "Compiled", "Generated", "EmbeddedSupport"],
             plugins: [.plugin(name: "GenerateOverlayForTesting")]
         ),
         .plugin(

Sources/WITOverlayGenerator/GuestGenerators/GuestPrelude.swift

@@ -4,7 +4,9 @@ let guestPrelude = """
     // Generated by the wit-overlay-generator
 
     #if arch(wasm32)
+    #if canImport(WASILibc)
     import WASILibc
+    #endif
     @_implementationOnly import _CabiShims
 
     fileprivate enum Prelude {
@@ -76,12 +78,14 @@ let guestPrelude = """
             _ array: [Element], elementSize: Int, elementAlignment: Int,
             storeElement: (Element, UnsafeMutableRawPointer) -> Void
         ) -> (pointer: UInt, length: UInt) {
-            let newBuffer = malloc(elementSize * array.count)
+            let newBuffer = UnsafeMutableRawPointer.allocate(
+                byteCount: elementSize * array.count, alignment: elementAlignment
+            )
             for (i, element) in array.enumerated() {
-                storeElement(element, newBuffer!.advanced(by: i * elementSize))
+                storeElement(element, newBuffer.advanced(by: i * elementSize))
             }
             return (
-                newBuffer.map { UInt(bitPattern: $0) } ?? 0, UInt(array.count)
+                UInt(bitPattern: newBuffer), UInt(array.count)
             )
         }
 
@@ -129,9 +133,12 @@ let guestPrelude = """
 
     // TODO: use `@_expose(wasm)`
     // NOTE: multiple objects in a component can have cabi_realloc definition so use `@_weakLinked` here.
+    #if canImport(WASILibc)
     @_weakLinked
     @_cdecl("cabi_realloc")
-    func cabi_realloc(old: UnsafeMutableRawPointer, oldSize: UInt, align: UInt, newSize: UInt) -> UnsafeMutableRawPointer {
-        realloc(old, Int(newSize))
+    func cabi_realloc(old: UnsafeMutableRawPointer?, oldSize: UInt, align: UInt, newSize: UInt) -> UnsafeMutableRawPointer? {
+        @_extern(c, "realloc") func realloc(_ old: UnsafeMutableRawPointer?, _ newSize: Int) -> UnsafeMutableRawPointer?
+        return realloc(old, Int(newSize))
     }
+    #endif
     """

Tests/WITOverlayGeneratorTests/EmbeddedSupport/MinLibc.c

@@ -0,0 +1,67 @@
+// This file is used to provide a "just enough" implementation of some C standard library functions
+// required by Embedded target builds.
+#include <stdint.h>
+#include <stddef.h>
+#define WASM_PAGE_SIZE 0x10000
+
+size_t __builtin_wasm_memory_grow(int32_t index, size_t delta);
+void *__builtin_memcpy(void *dest, const void *src, size_t n);
+
+static void* alignedAlloc(size_t alignment, size_t size) {
+    size_t basePageSize = __builtin_wasm_memory_grow(0, (size + 0xffff) / 0x10000);
+    if (basePageSize == (size_t)-1) {
+        return NULL;
+    }
+    size_t base = basePageSize * WASM_PAGE_SIZE;
+    base = (base + alignment - 1) & -alignment;
+    return (void*)base;
+}
+
+/// NOTE: always allocates a new memory page by `memory.grow`
+int posix_memalign(void** memptr, size_t alignment, size_t size) {
+    void* ptr = alignedAlloc(alignment, size);
+    if (ptr == NULL) {
+        return -1;
+    }
+    *memptr = ptr;
+    return 0;
+}
+
+/// NOTE: always allocates a new memory page by `memory.grow` and copies the old data
+void* cabi_realloc(void* old, size_t oldSize, size_t align, size_t newSize) {
+    if (old != NULL) {
+        void* new = alignedAlloc(align, newSize);
+        if (new != NULL) {
+            __builtin_memcpy(new, old, oldSize < newSize ? oldSize : newSize);
+        }
+        return new;
+    } else {
+        return alignedAlloc(align, newSize);
+    }
+}
+
+void *memmove(void *dest, const void *src, size_t n) {
+    return __builtin_memcpy(dest, src, n);
+}
+
+void *memcpy(void *dest, const void *src, size_t n) {
+    // `memory.copy` is safe even if `src` and `dest` overlap
+    // > Copying takes place as if an intermediate buffer were used, allowing the destination and source to overlap.
+    // > https://github.com/WebAssembly/bulk-memory-operations/blob/master/proposals/bulk-memory-operations/Overview.md
+    return __builtin_memcpy(dest, src, n);
+}
+
+/// NOTE: does nothing as we don't manage memory chunks
+void free(void *ptr) {}
+
+/// NOTE: just returns the input character as is, no output is produced
+int putchar(int c) {
+    return c;
+}
+
+/// NOTE: fills the buffer with a constant value
+void arc4random_buf(void *buf, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+        ((uint8_t *)buf)[i] = (uint8_t)42;
+    }
+}

Tests/WITOverlayGeneratorTests/Runtime/RuntimeSmokeTests.swift

@@ -5,8 +5,9 @@ import WIT
 class RuntimeSmokeTests: XCTestCase {
     func testCallExportByGuest() throws {
         var harness = try RuntimeTestHarness(fixture: "Smoke")
-        let (runtime, instance) = try harness.build(link: SmokeTestWorld.link(_:))
-        let component = SmokeTestWorld(moduleInstance: instance)
-        _ = try component.hello(runtime: runtime)
+        try harness.build(link: SmokeTestWorld.link(_:)) { (runtime, instance) in
+            let component = SmokeTestWorld(moduleInstance: instance)
+            _ = try component.hello(runtime: runtime)
+        }
     }
 }

Tests/WITOverlayGeneratorTests/Runtime/RuntimeTestHarness.swift

@@ -17,6 +17,7 @@ import XCTest
 struct RuntimeTestHarness {
     struct Configuration: Codable {
         let swiftExecutablePath: URL
+        let wasiSwiftSDK: URL
 
         var swiftCompilerExecutablePath: URL {
             swiftExecutablePath.deletingLastPathComponent().appendingPathComponent("swiftc")
@@ -53,9 +54,11 @@ struct RuntimeTestHarness {
             throw XCTSkip("""
             Please create 'Tests/default.json' with this or similar contents:
             {
-                "swiftExecutablePath": "/Library/Developer/Toolchains/swift-wasm-5.8.0-RELEASE.xctoolchain/usr/bin/swift"
+                "swiftExecutablePath": "$HOME/Library/Developer/Toolchains/swift-DEVELOPMENT-SNAPSHOT-2024-07-08-a.xctoolchain/usr/bin/swift",
+                "wasiSwiftSDK": "$HOME/Library/org.swift.swiftpm/swift-sdks/swift-wasm-DEVELOPMENT-SNAPSHOT-2024-07-09-a-wasm32-unknown-wasi.artifactbundle/DEVELOPMENT-SNAPSHOT-2024-07-09-a-wasm32-unknown-wasi/wasm32-unknown-wasi"
             }
 
+
             or specify `configuration` parameter in your test code.
             """)
         }
@@ -116,32 +119,70 @@ struct RuntimeTestHarness {
     }
 
     /// Build up WebAssembly module from the fixture and instantiate WasmKit runtime with the module.
-    mutating func build(link: (inout [String: HostModule]) -> Void) throws -> (Runtime, ModuleInstance) {
-        defer { cleanupTemporaryFiles() }
-        let compiled = try compile(inputFiles: collectGuestInputFiles())
-
-        let wasi = try WASIBridgeToHost(args: [compiled.path])
-        var hostModules: [String: HostModule] = wasi.hostModules
-        link(&hostModules)
-
-        let module = try parseWasm(filePath: .init(compiled.path))
-        let runtime = Runtime(hostModules: hostModules)
-        let instance = try runtime.instantiate(module: module)
-        return (runtime, instance)
+    mutating func build(
+        link: (inout [String: HostModule]) -> Void,
+        run: (Runtime, ModuleInstance) throws -> Void
+    ) throws {
+        for compile in [compileForEmbedded, compileForWASI] {
+            defer { cleanupTemporaryFiles() }
+            let compiled = try compile(collectGuestInputFiles())
+            
+            let wasi = try WASIBridgeToHost(args: [compiled.path])
+            var hostModules: [String: HostModule] = wasi.hostModules
+            link(&hostModules)
+            
+            let module = try parseWasm(filePath: .init(compiled.path))
+            let runtime = Runtime(hostModules: hostModules)
+            let instance = try runtime.instantiate(module: module)
+            try run(runtime, instance)
+        }
+    }
+
+    func compileForEmbedded(inputFiles: [String]) throws -> URL {
+        let embeddedSupport = Self.testsDirectory.appendingPathComponent("EmbeddedSupport")
+
+        let libc = embeddedSupport.appendingPathComponent("MinLibc.c")
+        let libcObjFile = Self.testsDirectory
+            .appendingPathComponent("Compiled")
+            .appendingPathComponent("MinLibc.o")
+        FileManager.default.createFile(atPath: libcObjFile.deletingLastPathComponent().path, contents: nil, attributes: nil)
+        try compileToObj(cInputFiles: [libc.path], arguments: [
+            "-target", "wasm32-unknown-none-wasm",
+            // Enable bulk memory operations for `realloc`
+            "-mbulk-memory",
+        ], outputPath: libcObjFile)
+
+        return try compile(inputFiles: inputFiles + [libcObjFile.path], arguments: [
+            "-target", "wasm32-unknown-none-wasm",
+            "-enable-experimental-feature", "Embedded",
+            "-wmo", "-Xcc", "-fdeclspec",
+            "-Xfrontend", "-disable-stack-protector",
+            "-Xlinker", "--no-entry", "-Xclang-linker", "-nostdlib",
+        ])
+    }
+
+    func compileForWASI(inputFiles: [String]) throws -> URL {
+        return try compile(inputFiles: inputFiles, arguments: [
+            "-target", "wasm32-unknown-wasi",
+            "-static-stdlib",
+            "-Xclang-linker", "-mexec-model=reactor",
+            "-resource-dir", configuration.wasiSwiftSDK.appendingPathComponent( "/swift.xctoolchain/usr/lib/swift_static").path,
+            "-sdk", configuration.wasiSwiftSDK.appendingPathComponent("WASI.sdk").path,
+            "-Xclang-linker", "-resource-dir",
+            "-Xclang-linker", configuration.wasiSwiftSDK.appendingPathComponent("swift.xctoolchain/usr/lib/swift_static/clang").path
+        ])
     }
 
     /// Compile the given input Swift source files into core Wasm module
-    func compile(inputFiles: [String]) throws -> URL {
+    func compile(inputFiles: [String], arguments: [String]) throws -> URL {
         let outputPath = Self.testsDirectory
             .appendingPathComponent("Compiled")
             .appendingPathComponent("\(fixtureName).core.wasm")
         try fileManager.createDirectory(at: outputPath.deletingLastPathComponent(), withIntermediateDirectories: true)
         let process = Process()
         process.launchPath = configuration.swiftCompilerExecutablePath.path
-        process.arguments = inputFiles + [
-            "-target", "wasm32-unknown-wasi",
+        process.arguments = inputFiles + arguments + [
             "-I\(Self.sourcesDirectory.appendingPathComponent("_CabiShims").appendingPathComponent("include").path)",
-            "-Xclang-linker", "-mexec-model=reactor",
             // TODO: Remove `--export-all` linker option by replacing `@_cdecl` with `@_expose(wasm)`
             "-Xlinker", "--export-all",
             "-o", outputPath.path
@@ -161,7 +202,9 @@ struct RuntimeTestHarness {
                 """
             }.joined(separator: "\n====================\n")      
             let message = """
-            Failed to execute \(process.arguments?.joined(separator: " ") ?? " ")
+            Failed to execute \(
+                ([configuration.swiftCompilerExecutablePath.path] + (process.arguments ?? [])).joined(separator: " ")
+            )
             Exit status: \(process.terminationStatus)
             Input files:
             \(fileContents)
@@ -170,4 +213,28 @@ struct RuntimeTestHarness {
         }
         return outputPath
     }
+
+    /// Compile the given input Swift source files into an object file
+    func compileToObj(cInputFiles: [String], arguments: [String], outputPath: URL) throws {
+        let process = Process()
+        // Assume that clang is placed alongside swiftc
+        process.launchPath = configuration.swiftCompilerExecutablePath
+            .deletingLastPathComponent().appendingPathComponent("clang").path
+        process.arguments = cInputFiles + arguments + [
+            "-c",
+            "-o", outputPath.path
+        ]
+        process.environment = [:]
+        process.launch()
+        process.waitUntilExit()
+        guard process.terminationStatus == 0 else {
+            let message = """
+            Failed to execute \(
+                ([configuration.swiftCompilerExecutablePath.path] + (process.arguments ?? [])).joined(separator: " ")
+            )
+            Exit status: \(process.terminationStatus)
+            """
+            throw Error(description: message)
+        }
+    }
 }