wardite 0.5.1 → 0.6.1

data/lib/wardite/wasi.rb

@@ -1,16 +1,161 @@
 # rbs_inline: enabled
+
+require "wardite/wasm_module"
+require "wardite/wasi/consts"
+require "securerandom"
+require "fcntl"
+
 module Wardite
   class WasiSnapshotPreview1
     include ValueHelper
+    include WasmModule
 
-    attr_accessor :fd_table #: Array[IO]
+    attr_accessor :fd_table #: Array[(IO|File)]
+    attr_accessor :argv #: Array[String]
 
-    def initialize
+    # @rbs argv: Array[String]
+    # @rbs return: void
+    def initialize(argv: [])
       @fd_table = [
         STDIN,
         STDOUT,
         STDERR,
       ]
+      @argv = argv
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def args_get(store, args)
+      arg_offsets_p = args[0].value
+      arg_data_buf_p = args[1].value
+      if !arg_data_buf_p.is_a?(Integer)
+        raise ArgumentError, "invalid type of args: #{args.inspect}"
+      end
+
+      arg_offsets = [] #: Array[Integer]
+      arg_data_slice = [] #: Array[String]
+      current_offset = arg_data_buf_p
+      @argv.each do |arg|
+        arg_offsets << current_offset
+        arg_data_slice << arg
+        current_offset += arg.size + 1
+      end
+      arg_data = arg_data_slice.join("\0") + "\0"
+
+      memory = store.memories[0]
+      memory.data[arg_data_buf_p...(arg_data_buf_p + arg_data.size)] = arg_data
+
+      arg_offsets.each_with_index do |offset, i|
+        data_begin = arg_offsets_p + i * 4
+        memory.data[data_begin...(data_begin + 4)] = [offset].pack("I!")
+      end
+
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def args_sizes_get(store, args)
+      argc_p = args[0].value
+      arglen_p = args[1].value
+      argc = @argv.length
+      arglen = @argv.map{|arg| arg.size + 1}.sum
+
+      memory = store.memories[0]
+      memory.data[argc_p...(argc_p+4)] = [argc].pack("I!")
+      memory.data[arglen_p...(arglen_p+4)] = [arglen].pack("I!")
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def environ_sizes_get(store, args)
+      envc_p = args[0].value
+      envlen_p = args[1].value
+      envc = ENV.length
+      envlen = ENV.map{|k,v| k.size + v.size + 1}.sum
+
+      memory = store.memories[0]
+      memory.data[envc_p...(envc_p+4)] = [envc].pack("I!")
+      memory.data[envlen_p...(envlen_p+4)] = [envlen].pack("I!")
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def environ_get(store, args)
+      environ_offsets_p = args[0].value
+      environ_data_buf_p = args[1].value
+      if !environ_data_buf_p.is_a?(Integer)
+        raise ArgumentError, "invalid type of args: #{args.inspect}"
+      end
+
+      environ_offsets = [] #: Array[Integer]
+      environ_data_slice = [] #: Array[String]
+      current_offset = environ_data_buf_p
+      ENV.each do |k, v|
+        environ_offsets << current_offset
+        environ_data_slice << "#{k}=#{v}"
+        current_offset += "#{k}=#{v}".size + 1
+      end
+      environ_data = environ_data_slice.join("\0") + "\0"
+
+      memory = store.memories[0]
+      memory.data[environ_data_buf_p...(environ_data_buf_p + environ_data.size)] = environ_data
+
+      environ_offsets.each_with_index do |offset, i|
+        data_begin = environ_offsets_p + i * 4
+        memory.data[data_begin...(data_begin + 4)] = [offset].pack("I!")
+      end
+
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def clock_time_get(store, args)
+      clock_id = args[0].value
+      # we dont use precision...
+      _precision = args[1].value
+      timebuf64 = args[2].value
+      if clock_id != 0 # - CLOCKID_REALTIME
+        # raise NotImplementedError, "CLOCKID_REALTIME is an only supported id"
+        return -255
+      end
+      # timestamp in nanoseconds
+      now = Time.now.to_i * 1_000_000
+
+      memory = store.memories[0]
+      now_packed = [now].pack("Q!")
+      memory.data[timebuf64...(timebuf64+8)] = now_packed
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def fd_prestat_get(store, args)
+      fd = args[0].value.to_i
+      prestat_offset = args[1].value.to_i
+      if fd >= @fd_table.size
+        return Wasi::EBADF
+      end
+      file = @fd_table[fd]
+      if !file.is_a?(File)
+        return Wasi::EBADF
+      end
+      name = file.path
+      memory = store.memories[0]
+      # Zero-value 8-bit tag, and 3-byte zero-value padding
+      memory.data[prestat_offset...(prestat_offset+4)] = [0].pack("I!")
+      memory.data[(prestat_offset+4)...(prestat_offset+8)] = [name.size].pack("I!")
+      0
     end
 
     # @rbs store: Store
@@ -29,6 +174,7 @@ module Wardite
         raise Wardite::ArgumentError, "args too short"
       end
       file = self.fd_table[fd]
+      return Wasi::EBADF if !file
       memory = store.memories[0]
       nwritten = 0
       iovs_len.times do
@@ -45,11 +191,126 @@ module Wardite
       0
     end
 
-    # @rbs return: Hash[Symbol, wasmCallable]
-    def to_module
-      {
-        fd_write: lambda{|store, args| self.fd_write(store, args) },
-      }
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def fd_read(store, args)
+      iargs = args.map do |elm|
+        if elm.is_a?(I32)
+          elm.value
+        else
+          raise Wardite::ArgumentError, "invalid type of args: #{args.inspect}"
+        end
+      end #: Array[Integer]
+      fd, iovs, iovs_len, rp = *iargs
+      if !fd || !iovs || !iovs_len || !rp
+        raise Wardite::ArgumentError, "args too short"
+      end
+      file = self.fd_table[fd]
+      return Wasi::EBADF if !file
+      memory = store.memories[0]
+      nread = 0
+      
+      iovs_len.times do
+        start = unpack_le_int(memory.data[iovs...(iovs+4)])
+        iovs += 4
+        slen = unpack_le_int(memory.data[iovs...(iovs+4)])
+        iovs += 4
+        buf = file.read(slen)
+        if !buf
+          return Wasi::EFAULT
+        end
+        memory.data[start...(start+slen)] = buf
+        nread += slen
+      end
+
+      memory.data[rp...(rp+4)] = [nread].pack("I!")
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def fd_fdstat_get(store, args)
+      fd = args[0].value.to_i
+      fdstat_offset = args[1].value.to_i
+      if fd >= @fd_table.size
+        return Wasi::EBADF
+      end
+      file = @fd_table[fd]
+      fdflags = 0
+      if file.is_a?(IO)
+        fdflags |= Wasi::FD_APPEND
+      else
+        if (Fcntl::O_APPEND & file.fcntl(Fcntl::F_GETFL, 0)) != 0
+          fdflags |= Wasi::FD_APPEND
+        end
+      end
+
+      if (Fcntl::O_NONBLOCK & file.fcntl(Fcntl::F_GETFL, 0)) != 0
+        fdflags |= Wasi::FD_NONBLOCK
+      end
+
+      stat = file.stat #: File::Stat
+      ftype = Wasi.to_ftype(stat.ftype)
+
+      fs_right_base = 0
+      fs_right_inheriting = 0
+
+      case ftype
+      when Wasi::FILETYPE_DIRECTORY
+        fs_right_base = Wasi::RIGHT_DIR_RIGHT_BASE
+        fs_right_inheriting = Wasi::RIGHT_FILE_RIGHT_BASE | Wasi::RIGHT_DIR_RIGHT_BASE
+      when Wasi::FILETYPE_CHARACTER_DEVICE
+        fs_right_base = Wasi::RIGHT_FILE_RIGHT_BASE & \
+          (~Wasi::RIGHT_FD_SEEK) & (~Wasi::RIGHT_FD_TELL)
+      else
+        fs_right_base = Wasi::RIGHT_FILE_RIGHT_BASE
+      end
+
+      memory = store.memories[0]
+
+      binformat = [fdflags, ftype, 0, 0, 0, 0, fs_right_base, fs_right_inheriting]
+        .pack("SSC4QQ")
+      memory.data[fdstat_offset...(fdstat_offset+binformat.size)] = binformat
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def fd_filestat_get(store, args)
+      fd = args[0].value.to_i
+      filestat_offset = args[1].value.to_i
+      if fd >= @fd_table.size
+        return Wasi::EBADF
+      end
+      file = @fd_table[fd]
+      stat = file.stat #: File::Stat
+      memory = store.memories[0]
+      binformat = [stat.dev, stat.ino, Wasi.to_ftype(stat.ftype), stat.nlink, stat.size, stat.atime.to_i, stat.mtime.to_i, stat.ctime.to_i].pack("Q8")
+      memory.data[filestat_offset...(filestat_offset+binformat.size)] = binformat
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def proc_exit(store, args)
+      exit_code = args[0].value
+      exit(exit_code)
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def random_get(store, args)
+      buf = args[0].value.to_i
+      buflen = args[1].value.to_i
+      randoms = SecureRandom.random_bytes(buflen) #: String
+      memory = store.memories[0]
+      memory.data[buf...(buf+buflen)] = randoms
+      0
     end
 
     private

data/lib/wardite/wasm_module.rb

@@ -0,0 +1,53 @@
+# rbs_inline: enabled
+
+module Wardite
+  # @rbs!
+  #   interface _WasmCallable
+  #     def call: (Store, Array[wasmValue]) -> wasmFuncReturn
+  #     def []: (Store, Array[wasmValue]) -> wasmFuncReturn
+  #   end
+
+  # @rbs!
+  #   type wasmModuleSrc = Hash[Symbol, _WasmCallable] | WasmModule | HashModule
+  #   type wasmModule    = WasmModule | HashModule
+
+  module WasmModule
+    # @rbs fnname: Symbol
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: wasmFuncReturn
+    def invoke(fnname, store, *args)
+      self.__send__(fnname, store, args)
+    end
+
+    # @rbs fnname: Symbol
+    # @rbs return: _WasmCallable
+    def callable(fnname)
+      self.method(fnname)
+    end
+  end
+
+  class HashModule
+    attr_accessor :hash #: Hash[Symbol, _WasmCallable]
+
+    # @rbs ha: Hash[Symbol, _WasmCallable]
+    def initialize(hash)
+      @hash = hash
+    end
+
+    # @rbs fnname: Symbol
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: wasmFuncReturn
+    def invoke(fnname, store, *args)
+      fn = self.hash[fnname.to_sym]
+      fn.call(store, args)
+    end
+
+    # @rbs fnname: Symbol
+    # @rbs return: _WasmCallable
+    def callable(fnname)
+      self.hash[fnname.to_sym]
+    end
+  end
+end

data/lib/wardite.rb

@@ -20,8 +20,6 @@ require_relative "wardite/alu_f32.generated"
 require_relative "wardite/alu_f64.generated"
 require_relative "wardite/convert.generated"
 
-require_relative "wardite/wasi"
-
 require "stringio"
 
 module Wardite
@@ -38,13 +36,23 @@ module Wardite
 
     attr_accessor :exports #: Exports
 
-    attr_reader :import_object #: Hash[Symbol, Hash[Symbol, wasmCallable]]
+    attr_reader :import_object #: Hash[Symbol, wasmModule]
+
+    attr_accessor :wasi #: WasiSnapshotPreview1?
 
-    # @rbs import_object: Hash[Symbol, Hash[Symbol, wasmCallable]]
+    # @rbs import_object: Hash[Symbol, wasmModuleSrc]
     # @rbs &blk: (Instance) -> void
     def initialize(import_object, &blk)
+      @wasi = nil
+
       blk.call(self)
-      @import_object = import_object
+      import_object.each_pair do |k, v|
+        if v.is_a?(Hash)
+          import_object[k] = HashModule.new(v)
+        end
+      end
+
+      @import_object = import_object #: Hash[Symbol, wasmModule]
 
       @store = Store.new(self)
       @exports = Exports.new(self.export_section, store)
@@ -281,7 +289,8 @@ module Wardite
 
       case fn
       when WasmFunction
-        invoke_internal(fn)
+        r = invoke_internal(fn)
+        r
       when ExternalFunction
         invoke_external(fn)
       else
@@ -313,25 +322,7 @@ module Wardite
         raise LoadError, "stack too short"
       end
       self.stack = drained_stack(local_start)
-
-      wasm_function.locals_count.each_with_index do |count, i|
-        typ = wasm_function.locals_type[i]
-        count.times do
-          case typ
-          when :i32, :u32
-            locals.push I32(0)
-          when :i64, :u64
-            locals.push I64(0)
-          when :f32
-            locals.push F32(0.0)
-          when :f64
-            locals.push F64(0.0)
-          else
-            $stderr.puts "warning: unknown type #{typ.inspect}. default to I32"
-            locals.push I32(0)
-          end
-        end
-      end
+      locals.concat(wasm_function.default_locals)
 
       arity = wasm_function.retsig.size
       frame = Frame.new(-1, stack.size, wasm_function.body, arity, locals)
@@ -888,7 +879,7 @@ module Wardite
   class Store
     attr_accessor :funcs #: Array[WasmFunction|ExternalFunction]
 
-    # FIXME: attr_accessor :modules
+    attr_accessor :modules #: Hash[Symbol, wasmModule]
 
     attr_accessor :memories #: Array[Memory]
 
@@ -907,21 +898,19 @@ module Wardite
 
       import_section = inst.import_section
       @funcs = []
+      @modules = inst.import_object
 
       if type_section && func_section && code_section
         import_section.imports.each do |desc|
           callsig = type_section.defined_types[desc.sig_index]
           retsig = type_section.defined_results[desc.sig_index]
-          imported_module = inst.import_object[desc.module_name.to_sym]
-          if !imported_module
+          target_module = self.modules[desc.module_name.to_sym]
+          if target_module.nil?
             raise ::NameError, "module #{desc.module_name} not found"
           end
-          imported_proc = imported_module[desc.name.to_sym]
-          if !imported_proc
-            raise ::NameError, "function #{desc.module_name}.#{desc.name} not found"
-          end
+          target_name = desc.name.to_sym
           
-          ext_function = ExternalFunction.new(callsig, retsig, imported_proc)
+          ext_function = ExternalFunction.new(target_module, target_name, callsig, retsig)
           self.funcs << ext_function
         end
 
@@ -1213,7 +1202,10 @@ module Wardite
   end
 
   # TODO: common interface btw. WasmFunction and ExternalFunction?
+  #       may be _WasmCallable?
   class WasmFunction
+    include ValueHelper
+
     attr_accessor :callsig #: Array[Symbol]
 
     attr_accessor :retsig #: Array[Symbol]
@@ -1222,6 +1214,8 @@ module Wardite
 
     attr_accessor :findex #: Integer
 
+    attr_accessor :default_locals #: Array[wasmValue]
+
     # @rbs callsig: Array[Symbol]
     # @rbs retsig: Array[Symbol]
     # @rbs code_body: CodeSection::CodeBody
@@ -1232,6 +1226,7 @@ module Wardite
 
       @code_body = code_body
       @findex = 0 # for debug
+      @default_locals = construct_default_locals
     end
 
     # @rbs return: Array[Op]
@@ -1249,6 +1244,30 @@ module Wardite
       code_body.locals_count
     end
 
+    # @rbs return: Array[wasmValue]
+    def construct_default_locals
+      locals = [] #: Array[wasmValue]
+      locals_count.each_with_index do |count, i|
+        typ = locals_type[i]
+        count.times do
+          case typ
+          when :i32, :u32
+            locals.push I32(0)
+          when :i64, :u64
+            locals.push I64(0)
+          when :f32
+            locals.push F32(0.0)
+          when :f64
+            locals.push F64(0.0)
+          else
+            $stderr.puts "warning: unknown type #{typ.inspect}. default to I32"
+            locals.push I32(0)
+          end
+        end
+      end
+      locals
+    end
+
     # @rbs override_type: Type?
     # @rbs return: WasmFunction
     def clone(override_type: nil)
@@ -1263,23 +1282,32 @@ module Wardite
 
   # @rbs!
   #   type wasmFuncReturn = Object|nil
-  #   type wasmCallable = ^(Store, Array[wasmValue]) -> wasmFuncReturn
 
   class ExternalFunction
+    attr_accessor :target_module #: wasmModule
+
+    attr_accessor :name #: Symbol
+
     attr_accessor :callsig #: Array[Symbol]
 
     attr_accessor :retsig #: Array[Symbol]
 
-    attr_accessor :callable #: wasmCallable
+    #attr_accessor :callable #: _WasmCallable
 
     # @rbs callsig: Array[Symbol]
     # @rbs retsig: Array[Symbol]
-    # @rbs callable: wasmCallable
+    # @rbs callable: _WasmCallable
     # @rbs return: void
-    def initialize(callsig, retsig, callable)
+    def initialize(target_module, name, callsig, retsig)
+      @target_module = target_module
+      @name = name
       @callsig = callsig
       @retsig = retsig
-      @callable = callable
+    end
+
+    # @rbs return: _WasmCallable
+    def callable()
+      target_module.callable(self.name)
     end
 
     # @rbs override_type: Type?
@@ -1287,9 +1315,9 @@ module Wardite
     def clone(override_type: nil)
       if override_type
         # callable is assumed to be frozen, so we can copy its ref
-        ExternalFunction.new(override_type.callsig, override_type.retsig, callable)
+        ExternalFunction.new(target_module, name, override_type.callsig, override_type.retsig)
       else
-        ExternalFunction.new(callsig, retsig, callable)
+        ExternalFunction.new(target_module, name, callsig, retsig)
       end
     end
   end

data/misc/bench-value.rb

@@ -0,0 +1,25 @@
+require "benchmark"
+require "wardite"
+
+N = 1000000
+
+i32_100 = Wardite::I32.new(100)
+i32_200 = Wardite::I32.new(200)
+$RES = {}
+$RES2 = {}
+
+Benchmark.bmbm do |x|
+  x.report("add via value") do
+    N.times do |i|
+      res = Wardite::I32.new(i32_100.value + i32_200.value)
+      $RES[i%10] = res # avoid optimization
+    end
+  end
+
+  x.report("add immediate") do
+    N.times do |i|
+      res = 100 + 200
+      $RES2[i%10] = res
+    end
+  end
+end

data/misc/slides/fib.c

@@ -0,0 +1,4 @@
+int fib(int n) {
+  if (n <= 1) return n;
+  return fib(n - 1) + fib(n - 2);
+}

data/misc/slides/fib.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <script>
+        WebAssembly.instantiateStreaming(fetch('./fib.wasm'))
+            .then(obj => {
+                alert(`fib(20) = ${obj.instance.exports.fib(20)}`);
+            });
+    </script>
+  </head>
+  <body>
+  </body>
+</html>