Fix errors when building WasmKit for WASI

Package.swift

@@ -89,14 +89,17 @@ let package = Package(
         .target(
             name: "SystemExtras",
             dependencies: [
-                .product(name: "SystemPackage", package: "swift-system")
+                .product(name: "SystemPackage", package: "swift-system"),
+                .target(name: "CSystemExtras", condition: .when(platforms: [.wasi])),
             ],
             exclude: ["CMakeLists.txt"],
             swiftSettings: [
                 .define("SYSTEM_PACKAGE_DARWIN", .when(platforms: DarwinPlatforms))
             ]
         ),
 
+        .target(name: "CSystemExtras"),
+
         .executableTarget(
             name: "WITTool",
             dependencies: [
@@ -121,7 +124,7 @@ let package = Package(
 if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
     package.dependencies += [
         .package(url: "https://github.com/apple/swift-argument-parser", from: "1.2.2"),
-        .package(url: "https://github.com/apple/swift-system", from: "1.6.0"),
+        .package(url: "https://github.com/apple/swift-system", from: "1.5.0"),
     ]
 } else {
     package.dependencies += [

Sources/CLI/Commands/Run.swift

@@ -59,12 +59,16 @@ struct Run: ParsableCommand {
     var directories: [String] = []
 
     enum ThreadingModel: String, ExpressibleByArgument, CaseIterable {
-        case direct
+        #if !os(WASI)
+            case direct
+        #endif
         case token
 
         func resolve() -> EngineConfiguration.ThreadingModel {
             switch self {
-            case .direct: return .direct
+            #if !os(WASI)
+                case .direct: return .direct
+            #endif
             case .token: return .token
             }
         }

Sources/CSystemExtras/include/clock.h

@@ -0,0 +1,5 @@
+#include <time.h>
+
+inline static clockid_t csystemextras_monotonic_clockid() {
+  return CLOCK_MONOTONIC;
+}

Sources/SystemExtras/Clock.swift

@@ -13,6 +13,7 @@ import Android
 import CSystem
 import ucrt
 #elseif os(WASI)
+import CSystemExtras
 import WASILibc
 #else
 #error("Unsupported Platform")
@@ -48,6 +49,11 @@ extension Clock {
   public static var monotonic: Clock { Clock(rawValue: _CLOCK_MONOTONIC) }
   #endif
 
+  #if os(WASI)
+  @_alwaysEmitIntoClient
+  public static var monotonic: Clock { Clock(rawValue: csystemextras_monotonic_clockid()) }
+  #endif
+
   #if os(OpenBSD) || os(FreeBSD)
   @_alwaysEmitIntoClient
   public static var uptime: Clock { Clock(rawValue: _CLOCK_UPTIME) }

Sources/WASI/Clock.swift

@@ -92,12 +92,10 @@ public protocol MonotonicClock {
     /// A monotonic clock that uses the system's monotonic clock.
     public struct SystemMonotonicClock: MonotonicClock {
         private var underlying: SystemExtras.Clock {
-            #if os(Linux) || os(Android)
+            #if os(Linux) || os(Android) || os(WASI)
                 return .monotonic
             #elseif os(macOS) || os(iOS) || os(watchOS) || os(tvOS) || os(visionOS)
                 return .rawUptime
-            #elseif os(WASI)
-                return .monotonic
             #elseif os(OpenBSD) || os(FreeBSD)
                 return .uptime
             #else

Sources/WASI/Platform/PlatformTypes.swift

@@ -43,14 +43,14 @@ extension WASIAbi.Fdflags {
             if platformOpenOptions.contains(.nonBlocking) {
                 fdFlags.insert(.NONBLOCK)
             }
-#if !os(WASI)
-            if platformOpenOptions.contains(.dataSync) {
-                fdFlags.insert(.DSYNC)
-            }
-            if platformOpenOptions.contains(.fileSync) {
-                fdFlags.insert(.SYNC)
-            }
-#endif
+            #if !os(WASI)
+                if platformOpenOptions.contains(.dataSync) {
+                    fdFlags.insert(.DSYNC)
+                }
+                if platformOpenOptions.contains(.fileSync) {
+                    fdFlags.insert(.SYNC)
+                }
+            #endif
             #if os(Linux)
                 if platformOpenOptions.contains(.readSync) {
                     fdFlags.insert(.RSYNC)
@@ -69,14 +69,14 @@ extension WASIAbi.Fdflags {
             if self.contains(.NONBLOCK) {
                 flags.insert(.nonBlocking)
             }
-#if !os(WASI)
-            if self.contains(.DSYNC) {
-                flags.insert(.dataSync)
-            }
-            if self.contains(.SYNC) {
-                flags.insert(.fileSync)
-            }
-#endif
+            #if !os(WASI)
+                if self.contains(.DSYNC) {
+                    flags.insert(.dataSync)
+                }
+                if self.contains(.SYNC) {
+                    flags.insert(.fileSync)
+                }
+            #endif
             #if os(Linux)
                 if self.contains(.RSYNC) {
                     flags.insert(.readSync)

Sources/WASI/Platform/SandboxPrimitives/Open.swift

@@ -129,13 +129,17 @@ struct PathResolution {
                         throw openErrno
                     }
 
-                    try self.symlink(component: component)
+                    #if os(WASI)
+                        throw Errno.notSupported
+                    #else
+                        try self.symlink(component: component)
+                    #endif
                 #endif
             }
         }
     }
 
-    #if !os(Windows)
+    #if !os(Windows) && !os(WASI)
         mutating func symlink(component: FilePath.Component) throws {
             /// Thin wrapper around readlinkat(2)
             func _readlinkat(_ fd: CInt, _ path: UnsafePointer<CChar>) throws -> FilePath {

Sources/WIT/PackageResolver.swift

@@ -241,4 +241,3 @@ public struct LocalFileLoader: PackageFileLoader {
         return try fileManager.contentsOfDirectory(atPath: depsDir.path)
     }
 }
-

Sources/WasmKit/Engine.swift

@@ -34,10 +34,12 @@ public struct EngineConfiguration {
     /// The threading model, which determines how to dispatch instruction
     /// execution, to use for the virtual machine interpreter.
     public enum ThreadingModel {
-        /// Direct threaded code
-        /// - Note: This is the default model for platforms that support
-        /// `musttail` calls.
-        case direct
+        #if !os(WASI)
+            /// Direct threaded code
+            /// - Note: This is the default model for platforms that support
+            /// `musttail` calls.
+            case direct
+        #endif
         /// Indirect threaded code
         /// - Note: This is a fallback model for platforms that do not support
         /// `musttail` calls.
@@ -48,7 +50,11 @@ public struct EngineConfiguration {
         }
 
         static var defaultForCurrentPlatform: ThreadingModel {
-            return useDirectThreadedCode ? .direct : .token
+            #if os(WASI)
+                return .token
+            #else
+                return useDirectThreadedCode ? .direct : .token
+            #endif
         }
     }
 

Sources/WasmKit/Execution/DispatchInstruction.swift

@@ -1930,6 +1930,7 @@ extension Execution {
     }
 }
 
+#if !os(WASI)
 extension Instruction {
     /// The tail-calling execution handler for the instruction.
     var handler: UInt {
@@ -1941,3 +1942,4 @@ extension Instruction {
         }
     }
 }
+#endif

Sources/WasmKit/Execution/Execution.swift

@@ -385,8 +385,10 @@ extension Execution {
         )
         do {
             switch self.store.value.engine.configuration.threadingModel {
-            case .direct:
-                try runDirectThreaded(sp: sp, pc: pc, md: md, ms: ms)
+            #if !os(WASI)
+                case .direct:
+                    try runDirectThreaded(sp: sp, pc: pc, md: md, ms: ms)
+            #endif
             case .token:
                 try runTokenThreaded(sp: &sp, pc: &pc, md: &md, ms: &ms)
             }
@@ -395,27 +397,29 @@ extension Execution {
         }
     }
 
-    /// Starts the main execution loop using the direct threading model.
-    @inline(never)
-    mutating func runDirectThreaded(
-        sp: Sp, pc: Pc, md: Md, ms: Ms
-    ) throws {
-        var pc = pc
-        let handler = pc.read(wasmkit_tc_exec.self)
-        wasmkit_tc_start(handler, sp, pc, md, ms, &self)
-        if let (rawError, trappingSp) = self.trap {
-            let error = unsafeBitCast(rawError, to: Error.self)
-            // Manually release the error object because the trap is caught in C and
-            // held as a raw pointer.
-            wasmkit_swift_errorRelease(rawError)
-
-            guard let trap = error as? Trap else {
-                throw error
+    #if !os(WASI)
+        /// Starts the main execution loop using the direct threading model.
+        @inline(never)
+        mutating func runDirectThreaded(
+            sp: Sp, pc: Pc, md: Md, ms: Ms
+        ) throws {
+            var pc = pc
+            let handler = pc.read(wasmkit_tc_exec.self)
+            wasmkit_tc_start(handler, sp, pc, md, ms, &self)
+            if let (rawError, trappingSp) = self.trap {
+                let error = unsafeBitCast(rawError, to: Error.self)
+                // Manually release the error object because the trap is caught in C and
+                // held as a raw pointer.
+                wasmkit_swift_errorRelease(rawError)
+
+                guard let trap = error as? Trap else {
+                    throw error
+                }
+                // Attach backtrace if the thrown error is a trap
+                throw trap.withBacktrace(Self.captureBacktrace(sp: trappingSp, store: store.value))
             }
-            // Attach backtrace if the thrown error is a trap
-            throw trap.withBacktrace(Self.captureBacktrace(sp: trappingSp, store: store.value))
         }
-    }
+    #endif
 
     #if EngineStats
         /// A helper structure for collecting instruction statistics.

Sources/WasmKit/Execution/Instructions/InstructionSupport.swift

@@ -220,8 +220,10 @@ typealias OpcodeID = UInt64
 extension Instruction {
     func headSlot(threadingModel: EngineConfiguration.ThreadingModel) -> CodeSlot {
         switch threadingModel {
-        case .direct:
-            return CodeSlot(handler)
+        #if !os(WASI)
+            case .direct:
+                return CodeSlot(handler)
+        #endif
         case .token:
             return opcodeID
         }

Sources/_CWasmKit/include/Platform.h

@@ -5,7 +5,7 @@
 // rather than a language standard feature after LLVM 19. We check
 // `__has_attribute(swiftasynccc)` too for compatibility with older versions.
 // See https://github.com/llvm/llvm-project/pull/85347
-#if __has_feature(swiftasynccc) || __has_extension(swiftasynccc)
+#if !defined(__wasi__) && (__has_feature(swiftasynccc) || __has_extension(swiftasynccc))
 #  define WASMKIT_HAS_SWIFTASYNCCC 1
 #else
 #  define WASMKIT_HAS_SWIFTASYNCCC 0

Sources/_CWasmKit/include/_CWasmKit.h

@@ -17,6 +17,7 @@ typedef void *_Nullable Pc;
 typedef void *_Nullable Md;
 typedef size_t Ms;
 
+#if WASMKIT_USE_DIRECT_THREADED_CODE
 /// The function type for executing a single instruction and transitioning to
 /// the next instruction by tail calling. `swiftasync` calling convention is
 /// used to keep `state` in the context register and to force tail calling.
@@ -40,6 +41,7 @@ static inline void wasmkit_tc_start(
 ) {
   exec(sp, pc, md, ms, state);
 }
+#endif
 
 static inline void wasmkit_fwrite_stderr(const char *_Nonnull str, size_t len) {
   fwrite(str, 1, len, stderr);

Utilities/Sources/VMGen.swift

@@ -460,6 +460,7 @@ enum VMGen {
                 + generateDirectThreadedCode(instructions: instructions, inlineImpls: inlineImpls)
                 + """
 
+                #if !os(WASI)
                 extension Instruction {
                     /// The tail-calling execution handler for the instruction.
                     var handler: UInt {
@@ -471,6 +472,7 @@ enum VMGen {
                         }
                     }
                 }
+                #endif
 
                 """
             ),