Implement wasi_snapshot_preview1 fd_write

Author: kubo39

dub.sdl

@@ -1,3 +1,4 @@
 name "tiny-wasm-runtime"
 authors "Hiroki Noda"
 copyright "Copyright © 2024, Hiroki Noda"
+dflags `-J./source/fixtures`

source/app.d

@@ -1,4 +1,14 @@
-import binary;
-import execution;
+import execution.wasi : WasiSnapshotPreview1;
+import execution.runtime : Runtime;
 
-void main() {}
+import std.stdio;
+
+void main()
+{
+    auto wasi = WasiSnapshotPreview1(
+        fileTable: [stdin, stdout, stderr]
+    );
+    const(ubyte)[] wasm = cast(const(ubyte)[]) import("hello_world.wasm");
+    auto runtime = Runtime.instantiate(wasm, wasi);
+    runtime.call("_start", []);
+}

source/execution/package.d

@@ -3,3 +3,4 @@ module execution;
 import execution.value;
 import execution.runtime;
 import execution.store;
+import execution.wasi;

source/execution/runtime.d

@@ -6,10 +6,12 @@ import binary.types;
 
 import execution.store;
 import execution.value;
+import execution.wasi : WasiSnapshotPreview1;
 
 import std.bitmanip : write;
 import std.exception : enforce;
 import std.range;
+import std.stdio;
 import std.sumtype;
 import std.system : Endian;
 import std.typecons;
@@ -35,6 +37,7 @@ private:
     Value[] stack;
     Frame*[] callStack;
     Import import_;
+    Nullable!WasiSnapshotPreview1 wasi;
 
     void execute()
     {
@@ -167,6 +170,13 @@ private:
         const bottom = this.stack.length - func.funcType.params.length;
         Value[] args = this.stack[bottom..$];
         this.stack = this.stack[0..bottom];
+        if (func.moduleName == "wasi_snapshot_preview1")
+        {
+            if (!this.wasi.isNull)
+            {
+                return this.wasi.get.invoke(this.store, func.func, args);
+            }
+        }
         const mod = func.moduleName in this.import_;
         enforce(mod !is null, "not found module");
         const importFunc = func.func in *mod;
@@ -175,11 +185,21 @@ private:
     }
 
 public:
-    static Runtime instantiate(ref const(ubyte)[] wasm)
+    static Runtime instantiate(const(ubyte)[] wasm)
+    {
+        auto mod = decodeModule(wasm);
+        auto store = Store(mod);
+        return Runtime(store: store);
+        }
+
+    static Runtime instantiate(const(ubyte)[] wasm, ref WasiSnapshotPreview1 wasi)
     {
         auto mod = decodeModule(wasm);
         auto store = Store(mod);
-        return Runtime(store);
+        return Runtime(
+            store: store,
+            wasi: nullable(wasi)
+        );
     }
 
     void addImport(string moduleName, string funcName, ImportFunc func)

source/execution/wasi.d

@@ -0,0 +1,69 @@
+module execution.wasi;
+
+import execution.value;
+import execution.store;
+
+import std.array : array;
+import std.bitmanip : peek, write;
+import std.stdio;
+import std.sumtype;
+import std.system : Endian;
+import std.typecons : Nullable, nullable;
+
+struct WasiSnapshotPreview1
+{
+    File[] fileTable;
+    
+    this(File[] fileTable)
+    {
+        this.fileTable = fileTable;
+    }
+
+    Nullable!Value invoke(ref Store store, string func, Value[] args)
+    {
+        switch (func)
+        {
+        case "fd_write":
+            return fdWrite(store, args);
+        default:
+            assert(false, "not implemented yet");
+        }
+        assert(false);
+    }
+
+    Nullable!Value fdWrite(ref Store store, Value[] args)
+    {
+        import std.algorithm : map;
+
+        int[] _args = args.map!((Value arg) {
+            return arg.match!(
+                (I32 i32) => i32.i,
+                _ => assert(false)
+            )();
+        }).array;
+
+        int fd = _args[0];
+        size_t iovs = _args[1];
+        int iovsLen = _args[2];
+        const size_t rp = _args[3];
+
+        auto file = fileTable[fd];
+        auto memory = store.memories[0];
+
+        int nwritten = 0;
+
+        foreach (_; 0..iovsLen)
+        {
+            const start = memory.data.peek!(int, Endian.littleEndian)(&iovs);
+            const len = memory.data.peek!(int, Endian.littleEndian)(&iovs);
+            const end = start + len;
+            file.rawWrite(memory.data[start..end]);
+            nwritten += len;
+        }
+        memory.data.write!(int, Endian.littleEndian)(nwritten, rp);
+
+        return nullable(cast(Value) I32(0));
+    }
+}
+
+

source/fixtures/hello_world.wasm

@@ -0,0 +1,24 @@
+(module
+  (import "wasi_snapshot_preview1" "fd_write"
+    (func $fd_write (param i32 i32 i32 i32) (result i32))
+  )
+  (memory 1)
+  (data (i32.const 0) "Hello, World!\n")
+
+  (func $hello_world (result i32)
+    (local $iovs i32)
+
+    (i32.store (i32.const 16) (i32.const 0))
+    (i32.store (i32.const 20) (i32.const 14))
+
+    (local.set $iovs (i32.const 16))
+
+    (call $fd_write
+      (i32.const 1)
+      (local.get $iovs)
+      (i32.const 1)
+      (i32.const 24)
+    )
+  )
+  (export "_start" (func $hello_world))
+)