wardite 0.2.2 → 0.4.0

data/lib/wardite.rb

@@ -31,13 +31,15 @@ module Wardite
 
     attr_accessor :runtime #: Runtime
 
+    attr_accessor :types #: Array[Type]
+
     attr_accessor :store #: Store
 
     attr_accessor :exports #: Exports
 
-    attr_reader :import_object #: Hash[Symbol, Hash[Symbol, Proc]]
+    attr_reader :import_object #: Hash[Symbol, Hash[Symbol, wasmCallable]]
 
-    # @rbs import_object: Hash[Symbol, Hash[Symbol, Proc]]
+    # @rbs import_object: Hash[Symbol, Hash[Symbol, wasmCallable]]
     # @rbs &blk: (Instance) -> void
     def initialize(import_object, &blk)
       blk.call(self)
@@ -46,6 +48,31 @@ module Wardite
       @store = Store.new(self)
       @exports = Exports.new(self.export_section, store)
       @runtime = Runtime.new(self)
+
+      @types = []
+      type_section = self.type_section
+      if type_section
+        type_section.defined_types.each_with_index do |calltype, idx|
+          rettype = type_section.defined_results[idx]
+          @types << Type.new(calltype, rettype)
+        end
+      end
+
+      check_data_count
+    end
+
+    # @rbs return: void
+    def check_data_count
+      data_count = self.data_count_section&.count
+      if data_count
+        actual_count = self.data_section&.segments&.size
+        if !actual_count
+          raise LoadError, "invalid data segment count"
+        end
+        if (data_count != actual_count)
+          raise LoadError, "invalid data segment count"
+        end
+      end
     end
 
     # @rbs return: ImportSection
@@ -82,6 +109,18 @@ module Wardite
       sec
     end
 
+    # @rbs return: StartSection|nil
+    def start_section
+      sec = @sections.find{|s| s.code == Const::SectionStart }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(StartSection)
+        raise(GenericError, "[BUG] found invalid start section")
+      end
+      sec
+    end
+
     # @rbs return: GlobalSection|nil
     def global_section
       sec = @sections.find{|s| s.code == Const::SectionGlobal }
@@ -106,6 +145,18 @@ module Wardite
       sec
     end
 
+    # @rbs return: DataCountSection|nil
+    def data_count_section
+      sec = @sections.find{|s| s.code == Const::SectionDataCount }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(DataCountSection)
+        raise(GenericError, "[BUG] found invalid data section")
+      end
+      sec
+    end
+
     # @rbs return: FunctionSection|nil
     def function_section
       sec = @sections.find{|s| s.code == Const::SectionFunction }
@@ -118,6 +169,30 @@ module Wardite
       sec
     end
 
+    # @rbs return: TableSection?
+    def table_section
+      sec = @sections.find{|s| s.code == Const::SectionTable }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(TableSection)
+        raise(GenericError, "instance doesn't have required section")
+      end
+      sec
+    end
+
+    # @rbs return: ElemSection?
+    def elem_section
+      sec = @sections.find{|s| s.code == Const::SectionElement }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(ElemSection)
+        raise(GenericError, "instance doesn't have required section")
+      end
+      sec
+    end
+
     # @rbs return: CodeSection|nil
     def code_section
       sec = @sections.find{|s| s.code == Const::SectionCode }
@@ -147,7 +222,7 @@ module Wardite
     include ValueHelper
 
     # TODO: add types of class that the stack accomodates
-    attr_accessor :stack #: Array[I32|I64|F32|F64]
+    attr_accessor :stack #: Array[wasmValue]
 
     attr_accessor :call_stack #: Array[Frame]
 
@@ -158,6 +233,16 @@ module Wardite
       @stack = []
       @call_stack = []
       @instance = inst
+
+      invoke_start_section
+    end
+
+    # @rbs return: void
+    def invoke_start_section
+      start_section = instance.start_section
+      if start_section
+        call_by_index(start_section.func_index)
+      end
     end
 
     # @rbs name: String|Symbol
@@ -200,6 +285,21 @@ module Wardite
       end
     end
 
+    # @rbs idx: Integer
+    # @rbs return: void
+    def call_by_index(idx)
+      fn = @instance.store.funcs[idx]
+
+      case fn
+      when WasmFunction
+        invoke_internal(fn)
+      when ExternalFunction
+        invoke_external(fn)
+      else
+        raise GenericError, "registered pointer is not to a function"
+      end
+    end
+
     # @rbs wasm_function: WasmFunction
     # @rbs return: void
     def push_frame(wasm_function)
@@ -249,7 +349,7 @@ module Wardite
     end
 
     # @rbs external_function: ExternalFunction
-    # @rbs return: I32|I64|F32|F64|nil
+    # @rbs return: wasmValue|nil
     def invoke_external(external_function)
       local_start = stack.size - external_function.callsig.size
       args = stack[local_start..]
@@ -326,19 +426,80 @@ module Wardite
       when :nop
         return
 
+      when :br
+        level = insn.operand[0]
+        raise EvalError, "br op without level" if !level.is_a?(Integer)
+        pc = do_branch(frame.labels, stack, level)
+        frame.pc = pc
+
+      when :br_if
+        level = insn.operand[0]
+        raise EvalError, "br op without level" if !level.is_a?(Integer)
+        cond = stack.pop 
+        raise EvalError, "cond not found" if !cond.is_a?(I32)
+        if cond.value.zero?
+          return
+        end
+        pc = do_branch(frame.labels, stack, level)
+        frame.pc = pc
+
+      when :br_table
+        level_vec = insn.operand[0]
+        raise EvalError, "no level vector" if !level_vec.is_a?(Array)
+        default = insn.operand[1]
+        raise EvalError, "no default specified" if !default.is_a?(Integer)
+        idx = stack.pop 
+        raise EvalError, "idx not found" if !idx.is_a?(I32)
+        level = if idx.value_s < 0 || idx.value_s >= level_vec.size
+          default
+        else
+          level_vec[idx.value_s]
+        end
+        pc = do_branch(frame.labels, stack, level)
+        frame.pc = pc
+
+      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)
+        label = Label.new(:block, next_pc, stack.size, block.result_size)
+        frame.labels.push(label)
+
+      when :loop
+        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)
+        frame.labels.push(label)
+
       when :if
         block = insn.operand[0]
         raise EvalError, "if op without block" if !block.is_a?(Block)
         cond = stack.pop 
         raise EvalError, "cond not found" if !cond.is_a?(I32)
         next_pc = fetch_ops_while_end(frame.body, frame.pc)
+
         if cond.value.zero?
-          frame.pc = next_pc
+          frame.pc = fetch_ops_while_else_or_end(frame.body, frame.pc)
+        end
+
+        if frame.pc == next_pc
+          # This means if block has no else instr.
+          return
         end
 
         label = Label.new(:if, next_pc, stack.size, block.result_size)
         frame.labels.push(label)
 
+      when :else
+        if old_label = frame.labels.pop
+          frame.pc = old_label.pc
+          stack_unwind(old_label.sp, old_label.arity)
+        else
+          raise EvalError, "else should be in if block"
+        end
+
       when :call
         idx = insn.operand[0]
         raise EvalError, "[BUG] local operand not found" if !idx.is_a?(Integer)
@@ -353,6 +514,45 @@ module Wardite
           raise GenericError, "got a non-function pointer"
         end
 
+      when :call_indirect
+        table = self.instance.store.tables[0]
+        raise EvalError, "table required but not found" if !table
+        type_idx = insn.operand[0]
+        raise EvalError, "[BUG] index operand invalid" if !type_idx.is_a?(Integer)
+        nullbyte = insn.operand[1]
+        raise EvalError, "[BUG] invalid bytearray of call_indirect" if nullbyte != 0x0
+        table_idx = stack.pop
+        raise EvalError, "[BUG] index stack invalid" if !table_idx.is_a?(I32)
+        fntype = self.instance.types[type_idx]
+        if !fntype
+          raise EvalError, "undefined type index: idx=#{type_idx}"          
+        end
+        refs = self.instance.store.tables[0]&.refs
+        if !refs
+           raise EvalError, "uninitialized element idx:#{table_idx}"
+        end
+
+        fn = refs[table_idx.value]
+        case fn
+        when WasmFunction
+          if table.type != :funcref
+            raise EvalError, "invalid type of elem; expected: #{table.type}"
+          end
+          fn = fn.clone(override_type: fntype)
+          push_frame(fn)
+        when ExternalFunction
+          if table.type != :externref
+            raise EvalError, "invalid type of elem; expected: #{table.type}"
+          end
+          fn = fn.clone(override_type: fntype)
+          ret = invoke_external(fn)
+          self.stack.push ret if ret
+        when nil
+          raise EvalError, "uninitialized element idx:#{table_idx.value}"
+        else
+          raise EvalError, "[BUG] unknwon function type #{fn}"
+        end
+
       when :return
         old_frame = call_stack.pop
         if !old_frame
@@ -408,6 +608,18 @@ module Wardite
         end
         frame.locals[idx] = value
 
+      when :local_tee
+        idx = insn.operand[0]
+        if !idx.is_a?(Integer)
+          raise EvalError, "[BUG] invalid type of operand"
+        end
+        value = stack.pop
+        if !value
+          raise EvalError, "value should be pushed"
+        end
+        frame.locals[idx] = value
+        stack.push value
+
       when :global_get
         idx = insn.operand[0]
         if !idx.is_a?(Integer)
@@ -450,17 +662,126 @@ module Wardite
         memory = instance.store.memories[0] || raise("[BUG] no memory")
         stack.push(I32(memory.grow(delta.value)))
 
+      when :memory_init
+        idx = insn.operand[0]
+        if !idx.is_a?(Integer)
+          raise EvalError, "[BUG] invalid type of operand"
+        end
+        if insn.operand[1] != 0x0
+          $stderr.puts "warning: :memory_init is not ending with 0x00"
+        end
+        data_sec = instance.data_section
+        if !data_sec
+          raise EvalError, "data segment out of range"
+        end
+        data_seg = data_sec.segments[idx]
+        if !data_seg
+          raise EvalError, "data segment out of range"
+        end
+
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        length, src_offset, dest_offset = stack.pop, stack.pop, stack.pop
+        if !length.is_a?(I32) || !src_offset.is_a?(I32) || !dest_offset.is_a?(I32)
+          raise EvalError, "invalid stack values"
+        end
+        source = data_seg.data[src_offset.value...(src_offset.value+length.value)]
+        raise EvalError, "invalid source range" if !source
+        memory.data[dest_offset.value...(dest_offset.value+length.value)] = source
+
+      when :memory_copy
+        if insn.operand[0] != 0x0 || insn.operand[1] != 0x0
+          $stderr.puts "warning: :memory_copy is not ending with 0x00"
+        end
+        length, src_offset, dest_offset = stack.pop, stack.pop, stack.pop
+        if !length.is_a?(I32) || !src_offset.is_a?(I32) || !dest_offset.is_a?(I32)
+          raise EvalError, "invalid stack values"
+        end
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        source = memory.data[src_offset.value...(src_offset.value+length.value)]
+        raise EvalError, "invalid source range" if !source
+        memory.data[dest_offset.value...(dest_offset.value+length.value)] = source
+
+      when :memory_fill
+        if insn.operand[0] != 0x0
+          $stderr.puts "warning: :memory_fill is not ending with 0x00"
+        end
+        length, byte, dest_offset = stack.pop, stack.pop, stack.pop
+        if !length.is_a?(I32) || !byte.is_a?(I32) || !dest_offset.is_a?(I32)
+          raise EvalError, "invalid stack values"
+        end
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        source = byte.value.chr * length.value
+        memory.data[dest_offset.value...(dest_offset.value+length.value)] = source
+
       else
         raise "TODO! unsupported #{insn.inspect}"
       end
 
     rescue => e
       require "pp"
+      $stderr.puts "instance:::\n#{self.instance.pretty_inspect}"
       $stderr.puts "frame:::\n#{frame.pretty_inspect}"
       $stderr.puts "stack:::\n#{stack.pretty_inspect}"
       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
+    # @rbs return: Integer
+    def do_branch(labels, stack, level)
+      idx = labels.size - 1 - level
+      label = labels[idx]
+      pc = if label.kind == :loop
+        # keep the top of labels for loop again...
+        while labels.size > idx + 1
+          labels.pop
+        end
+        stack_unwind(label.sp, 0)
+        label.start || raise(EvalError, "loop withour start")
+      else
+        while labels.size > idx
+          labels.pop
+        end
+        stack_unwind(label.sp, label.arity)
+        label.pc
+      end
+
+      pc
+    end
+
     # @rbs ops: Array[Op]
     # @rbs pc_start: Integer
     # @rbs return: Integer
@@ -473,7 +794,7 @@ module Wardite
         case inst&.code
         when nil
           raise EvalError, "end op not found"
-        when :i
+        when :if, :block, :loop
           depth += 1
         when :end
           if depth == 0
@@ -509,7 +830,7 @@ module Wardite
     end
 
     # @rbs finish: Integer
-    # @rbs return: Array[I32|I64|F32|F64]
+    # @rbs return: Array[wasmValue]
     def drained_stack(finish)
       drained = stack[0...finish]
       if ! drained
@@ -537,6 +858,20 @@ module Wardite
     end
   end
 
+  class Type
+    attr_accessor :callsig #: Array[Symbol]
+
+    attr_accessor :retsig #: Array[Symbol]
+
+    # @rbs callsig: Array[Symbol]
+    # @rbs retsig: Array[Symbol]
+    # @rbs returb: void
+    def initialize(callsig, retsig)
+      @callsig = callsig
+      @retsig = retsig
+    end
+  end
+
   class Frame
     attr_accessor :pc #: Integer
     attr_accessor :sp #: Integer
@@ -547,13 +882,13 @@ module Wardite
 
     attr_accessor :labels #: Array[Label]
 
-    attr_accessor :locals #: Array[I32|I64|F32|F64]
+    attr_accessor :locals #: Array[wasmValue]
 
     # @rbs pc: Integer
     # @rbs sp: Integer
     # @rbs body: Array[Op]
     # @rbs arity: Integer
-    # @rbs locals: Array[Object]
+    # @rbs locals: Array[wasmValue]
     # @rbs returb: void
     def initialize(pc, sp, body, arity, locals)
       @pc = pc
@@ -573,16 +908,20 @@ module Wardite
 
     attr_accessor :arity #: Integer
 
+    attr_accessor :start #: Integer|nil
+
     # @rbs kind: (:if|:loop|:block)
     # @rbs pc: Integer
     # @rbs sp: Integer
     # @rbs arity: Integer
-    # @rbs returb: void
-    def initialize(kind, pc, sp, arity)
+    # @rbs start: Integer|nil
+    # @rbs return: void
+    def initialize(kind, pc, sp, arity, start=nil)
       @kind = kind
       @pc = pc
       @sp = sp
       @arity = arity
+      @start = start
     end
   end
 
@@ -595,6 +934,10 @@ module Wardite
 
     attr_accessor :globals #: Array[Global]
 
+    attr_accessor :tables #: Array[Table]
+
+    attr_accessor :elements #: Array[[Symbol, Integer, Array[Integer]]]
+
     # @rbs inst: Instance
     # @rbs return: void
     def initialize(inst)
@@ -641,9 +984,12 @@ module Wardite
         data_section = inst.data_section
         if data_section
           data_section.segments.each do |segment|
-            memory = self.memories[segment.flags]
+            if segment.mode != :active
+              next
+            end
+            memory = self.memories[segment.mem_index]
             if !memory
-              raise GenericError, "invalid memory index: #{segment.flags}"
+              raise GenericError, "invalid memory index: #{segment.mem_index}"
             end
 
             data_start = segment.offset
@@ -669,6 +1015,56 @@ module Wardite
           end
         end
       end
+
+      @tables = []
+      @elements = []
+      table_section = inst.table_section
+      if table_section
+        table_section.table_types.each_with_index do |typ, idx|
+          init, max = *table_section.table_limits[idx]
+          if !init
+            raise LoadError, "empty limits"
+          end
+          table = Table.new(typ, init, max)
+          @tables << table
+        end
+      end
+
+      elem_section = inst.elem_section
+      if elem_section
+        elem_section.table_indices.each_with_index do |tidx, idx|
+          table = @tables[tidx]
+          if !table
+            raise LoadError, "invalid table index #{tidx}"
+          end
+          typ = table.type
+          offset = elem_section.table_offsets[idx]
+          if !offset
+            raise LoadError, "invalid element index #{idx}"
+          end
+          indices = elem_section.element_indices[idx]
+          if !indices
+            raise LoadError, "invalid element index #{idx}"
+          end
+          elms = [typ, offset, indices] #: [Symbol, Integer, Array[Integer]]
+          @elements << elms
+        end
+      end
+
+      @elements.each_with_index do |(typ, offset, indices), idx|
+        table = @tables[idx]
+        if !table
+          raise LoadError, "invalid table index #{idx}"          
+        end
+        indices.each_with_index do |eidx, tidx|
+          case typ
+          when :funcref
+            table.set(offset + tidx, @funcs[eidx])
+          when :externref
+            raise NotImplementedError, "no support :externref"
+          end
+        end
+      end
     end
 
     # @rbs idx: Integer
@@ -711,6 +1107,38 @@ module Wardite
     end
   end
 
+  class Table
+    attr_accessor :type #: Symbol
+    
+    attr_accessor :current #: Integer
+
+    attr_accessor :max #: Integer|nil
+    
+    attr_accessor :refs #: Array[WasmFunction|ExternalFunction|nil]
+
+    # @rbs type: Symbol
+    # @rbs init: Integer
+    # @rbs max: Integer|nil
+    # @rbs return: void
+    def initialize(type, init, max)
+      @type = type
+      @current = init
+      @max = max
+
+      @refs = Array.new(3, nil)
+    end
+
+    # @rbs idx: Integer
+    # @rbs elem: WasmFunction|ExternalFunction|nil
+    # @rbs return: void
+    def set(idx, elem)
+      if idx >= @current
+        raise GenericError, "idx too large for table"
+      end
+      @refs[idx] = elem
+    end
+  end
+
   class Global
     attr_accessor :type #: Symbol
     
@@ -719,7 +1147,7 @@ module Wardite
     # TODO: unused in wasm 1.0 spec?
     attr_accessor :shared #: bool
 
-    attr_accessor :value #: I32|I64|F32|F64
+    attr_accessor :value #: wasmValue
 
     # @rbs &blk: (Global) -> void
     # @rbs return: void
@@ -829,25 +1257,51 @@ module Wardite
     # @rbs return: Array[Integer]
     def locals_count
       code_body.locals_count
-    end    
+    end
+
+    # @rbs override_type: Type?
+    # @rbs return: WasmFunction
+    def clone(override_type: nil)
+      if override_type
+        # code_body is assumed to be frozen, so we can copy its ref
+        WasmFunction.new(override_type.callsig, override_type.retsig, code_body)
+      else
+        WasmFunction.new(callsig, retsig, code_body)
+      end
+    end
   end
 
+  # @rbs!
+  #   type wasmFuncReturn = Object|nil
+  #   type wasmCallable = ^(Store, Array[wasmValue]) -> wasmFuncReturn
+
   class ExternalFunction
     attr_accessor :callsig #: Array[Symbol]
 
     attr_accessor :retsig #: Array[Symbol]
 
-    attr_accessor :callable #: Proc
+    attr_accessor :callable #: wasmCallable
 
     # @rbs callsig: Array[Symbol]
     # @rbs retsig: Array[Symbol]
-    # @rbs callable: Proc
+    # @rbs callable: wasmCallable
     # @rbs return: void
     def initialize(callsig, retsig, callable)
       @callsig = callsig
       @retsig = retsig
       @callable = callable
     end
+
+    # @rbs override_type: Type?
+    # @rbs return: ExternalFunction
+    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)
+      else
+        ExternalFunction.new(callsig, retsig, callable)
+      end
+    end
   end
 
   class GenericError < StandardError; end