wardite 0.5.0 → 0.6.0

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)
@@ -473,7 +464,7 @@ module Wardite
       when :block
         block = insn.operand[0]
         raise EvalError, "block op without block" if !block.is_a?(Block)
-        next_pc = fetch_ops_while_end(frame.body, frame.pc)
+        next_pc = insn.meta[:end_pos]
         label = Label.new(:block, next_pc, stack.size, block.result_size)
         frame.labels.push(label)
 
@@ -481,19 +472,19 @@ module Wardite
         block = insn.operand[0]
         raise EvalError, "loop op without block" if !block.is_a?(Block)
         start = frame.pc
-        end_pc = fetch_ops_while_end(frame.body, frame.pc)
-        label = Label.new(:loop, end_pc, stack.size, block.result_size, start)
+        next_pc = insn.meta[:end_pos]
+        label = Label.new(:loop, next_pc, stack.size, block.result_size, start)
         frame.labels.push(label)
 
       when :if
         block = insn.operand[0]
         raise EvalError, "if op without block" if !block.is_a?(Block)
-        cond = stack.pop 
+        cond = stack.pop
         raise EvalError, "cond not found" if !cond.is_a?(I32)
-        next_pc = fetch_ops_while_end(frame.body, frame.pc)
+        next_pc = insn.meta[:end_pos]
 
         if cond.value.zero?
-          frame.pc = fetch_ops_while_else_or_end(frame.body, frame.pc)
+          frame.pc = insn.meta[:else_pos]
         end
 
         if frame.pc == next_pc
@@ -740,38 +731,6 @@ module Wardite
       raise e
     end
 
-    # @rbs ops: Array[Op]
-    # @rbs pc_start: Integer
-    # @rbs return: Integer
-    def fetch_ops_while_else_or_end(ops, pc_start)
-      cursor = pc_start
-      depth = 0
-      loop {
-        cursor += 1
-        inst = ops[cursor]
-        case inst&.code
-        when nil
-          raise EvalError, "end op not found"
-        when :if
-          depth += 1
-        when :else
-          if depth == 0
-            return cursor
-          end
-          # do not touch depth
-        when :end
-          if depth == 0
-            return cursor
-          else
-            depth -= 1
-          end
-        else
-          # nop
-        end
-      }
-      raise "[BUG] unreachable"
-    end
-
     # @rbs labels: Array[Label]
     # @rbs stack: Array[wasmValue]
     # @rbs level: Integer
@@ -797,33 +756,6 @@ module Wardite
       pc
     end
 
-    # @rbs ops: Array[Op]
-    # @rbs pc_start: Integer
-    # @rbs return: Integer
-    def fetch_ops_while_end(ops, pc_start)
-      cursor = pc_start
-      depth = 0
-      loop {
-        cursor += 1
-        inst = ops[cursor]
-        case inst&.code
-        when nil
-          raise EvalError, "end op not found"
-        when :if, :block, :loop
-          depth += 1
-        when :end
-          if depth == 0
-            return cursor
-          else
-            depth -= 1
-          end
-        else
-          # nop
-        end
-      }
-      raise "[BUG] unreachable"
-    end
-
     # unwind the stack and put return value if exists
     # @rbs sp: Integer
     # @rbs arity: Integer
@@ -947,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]
 
@@ -966,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
 
@@ -1272,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]
@@ -1281,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
@@ -1291,6 +1226,7 @@ module Wardite
 
       @code_body = code_body
       @findex = 0 # for debug
+      @default_locals = construct_default_locals
     end
 
     # @rbs return: Array[Op]
@@ -1308,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)
@@ -1322,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?
@@ -1346,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