wardite 0.2.0 → 0.2.1

data/lib/wardite.rb

@@ -13,6 +13,10 @@ module Wardite
   end
 end
 require_relative "wardite/alu_i32.generated"
+require_relative "wardite/alu_i64.generated"
+require_relative "wardite/alu_f32.generated"
+require_relative "wardite/alu_f64.generated"
+require_relative "wardite/convert.generated"
 
 require_relative "wardite/wasi"
 
@@ -290,6 +294,10 @@ module Wardite
             arg << :i32
           when 0x7e
             arg << :i64
+          when 0x7d
+            arg << :f32
+          when 0x7c
+            arg << :f64
           else
             raise NotImplementedError, "unsupported for now: #{ty.inspect}"
           end
@@ -304,6 +312,10 @@ module Wardite
             ret << :i32
           when 0x7e
             ret << :i64
+          when 0x7d
+            ret << :f32
+          when 0x7c
+            ret << :f64
           else
             raise NotImplementedError, "unsupported for now: #{ty.inspect}"
           end
@@ -432,14 +444,38 @@ module Wardite
         operand = [] #: Array[Integer|Float|Block]
         operand_types.each do |typ|
           case typ
+          when :u8
+            ope = buf.read 1
+            if ! ope
+              raise LoadError, "buffer too short"
+            end
+            operand << ope.ord
           when :u32
             operand << fetch_uleb128(buf)
           when :i32
             operand << fetch_sleb128(buf)
-          when :u8_block # :if specific
+          when :i64
+            operand << fetch_sleb128(buf)
+          when :f32
+            data = buf.read 4
+            if !data || data.size != 4
+              raise LoadError, "buffer too short"
+            end
+            v = data.unpack("e")[0]
+            raise "String#unpack is broken" if !v.is_a?(Float)
+            operand << v
+          when :f64
+            data = buf.read 8
+            if !data || data.size != 8
+              raise LoadError, "buffer too short"
+            end
+            v = data.unpack("E")[0]
+            raise "String#unpack is broken" if !v.is_a?(Float)
+            operand << v
+          when :u8_if_block # :if specific
             block_ope = buf.read 1
             if ! block_ope
-              raise "buffer too short for if"
+              raise LoadError, "buffer too short for if"
             end
             if block_ope.ord == 0x40
               operand << Block.void
@@ -688,7 +724,7 @@ module Wardite
     include ValueHelper
 
     # TODO: add types of class that the stack accomodates
-    attr_accessor :stack #: Array[I32|I64|F32|F64|Block]
+    attr_accessor :stack #: Array[I32|I64|F32|F64]
 
     attr_accessor :call_stack #: Array[Frame]
 
@@ -848,12 +884,25 @@ module Wardite
     # @rbs return: void
     def eval_insn(frame, insn)
       case insn.namespace
+      when :convert
+        return Evaluator.convert_eval_insn(self, frame, insn)
       when :i32
         return Evaluator.i32_eval_insn(self, frame, insn)
+      when :i64
+        return Evaluator.i64_eval_insn(self, frame, insn)
+      when :f32
+        return Evaluator.f32_eval_insn(self, frame, insn)
+      when :f64
+        return Evaluator.f64_eval_insn(self, frame, insn)
       end
 
       # unmached namespace...
       case insn.code
+      when :unreachable
+        raise Unreachable, "unreachable op"
+      when :nop
+        return
+
       when :if
         block = insn.operand[0]
         raise EvalError, "if op without block" if !block.is_a?(Block)
@@ -866,78 +915,6 @@ module Wardite
 
         label = Label.new(:if, next_pc, stack.size, block.result_size)
         frame.labels.push(label)
-        
-      when :local_get
-        idx = insn.operand[0]
-        if !idx.is_a?(Integer)
-          raise EvalError, "[BUG] invalid type of operand"
-        end
-        local = frame.locals[idx]
-        if !local
-          raise EvalError, "local not found"
-        end
-        stack.push(local)
-      when :local_set
-        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
-        if value.is_a?(Block)
-          raise EvalError, "block value detected"
-        end
-        frame.locals[idx] = value
-
-      # when :i32_lts
-      #   right, left = stack.pop, stack.pop
-      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
-      #     raise EvalError, "maybe empty stack"
-      #   end
-      #   value = (left < right) ? 1 : 0
-      #   stack.push(value)
-      # when :i32_leu
-      #   right, left = stack.pop, stack.pop
-      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
-      #     raise EvalError, "maybe empty stack"
-      #   end
-      #   value = (left >= right) ? 1 : 0
-      #   stack.push(value)
-      # when :i32_add
-      #   right, left = stack.pop, stack.pop
-      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
-      #     raise EvalError, "maybe empty stack"
-      #   end
-      #   stack.push(left + right)
-      # when :i32_sub
-      #   right, left = stack.pop, stack.pop
-      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
-      #     raise EvalError, "maybe empty stack"
-      #   end
-      #   stack.push(left - right)
-      # when :i32_const
-      #   const = insn.operand[0]
-      #   if !const.is_a?(Integer)
-      #     raise EvalError, "[BUG] invalid type of operand"
-      #   end
-      #   stack.push(const)
-      # when :i32_store
-      #   _align = insn.operand[0] # TODO: alignment support?
-      #   offset = insn.operand[1]
-      #   raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
-
-      #   value = stack.pop
-      #   addr = stack.pop
-      #   if !value.is_a?(Integer) || !addr.is_a?(Integer)
-      #     raise EvalError, "maybe stack too short"
-      #   end
-
-      #   at = addr + offset
-      #   data_end = at + 4 # sizeof(i32)
-      #   memory = self.instance.store.memories[0] || raise("[BUG] no memory")
-      #   memory.data[at...data_end] = [value].pack("I")
 
       when :call
         idx = insn.operand[0]
@@ -972,7 +949,63 @@ module Wardite
           end
           stack_unwind(old_frame.sp, old_frame.arity)
         end
+
+      when :drop
+        stack.pop
+
+      when :select
+        cond, right, left = stack.pop, stack.pop, stack.pop
+        if !cond.is_a?(I32)
+          raise EvalError, "invalid stack for select"
+        end
+        if !right || !left
+          raise EvalError, "stack too short"
+        end
+        stack.push(cond.value != 0 ? left : right)
+
+      when :local_get
+        idx = insn.operand[0]
+        if !idx.is_a?(Integer)
+          raise EvalError, "[BUG] invalid type of operand"
+        end
+        local = frame.locals[idx]
+        if !local
+          raise EvalError, "local not found"
+        end
+        stack.push(local)
+
+      when :local_set
+        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
+
+      when :memory_size
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        stack.push(I32(memory.current))
+
+      when :memory_grow
+        delta = stack.pop
+        if !delta.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        stack.push(I32(memory.grow(delta.value)))
+
+      else
+        raise "TODO! unsupported #{insn.inspect}"
       end
+
+    rescue => e
+      require "pp"
+      $stderr.puts "frame:::\n#{frame.pretty_inspect}"
+      $stderr.puts "stack:::\n#{stack.pretty_inspect}"
+      raise e
     end
 
     # @rbs ops: Array[Op]
@@ -1023,7 +1056,7 @@ module Wardite
     end
 
     # @rbs finish: Integer
-    # @rbs return: Array[I32|I64|F32|F64|Block]
+    # @rbs return: Array[I32|I64|F32|F64]
     def drained_stack(finish)
       drained = stack[0...finish]
       if ! drained
@@ -1179,16 +1212,32 @@ module Wardite
   class Memory
     attr_accessor :data #: String
 
+    attr_accessor :current #: Integer
+
     attr_accessor :max #: Integer|nil
 
     # @rbs min: Integer
     # @rbs max: Integer|nil
     # @rbs return: void
     def initialize(min, max)
-      @data = String.new("\0" * (min * 64 * 1024), capacity: min * 64 * 1024)
+      @data = String.new("\0" * (min * 64 * 1024))
+      @current = min
       @max = max
     end
 
+    # @rbs delta: Integer
+    # @rbs return: Integer
+    def grow(delta)
+      prev = current
+      newsize = current + delta
+      if max && (newsize > max)
+        return -1
+      end
+      
+      @data += String.new("\0" * (delta * 64 * 1024))
+      prev
+    end
+
     def inspect
       "#<Wardite::Memory initial=#{@data.size.inspect} max=#{@max.inspect} @data=#{@data[0...64].inspect}...>"
     end
@@ -1317,6 +1366,7 @@ module Wardite
   class LoadError < StandardError; end
   class ArgumentError < StandardError; end
   class EvalError < StandardError; end
+  class Unreachable < StandardError; end
 
   # @rbs path: String|nil
   # @rbs buffer: File|StringIO|nil