wardite 0.2.0 → 0.2.2

data/lib/wardite/alu_f64.generated.rb

@@ -0,0 +1,250 @@
+# rbs_inline: enabled
+require_relative "value"
+
+module Wardite
+  module Evaluator
+    # @rbs runtime: Runtime
+    # @rbs frame: Frame
+    # @rbs insn: Op
+    # @rbs return: void 
+    def self.f64_eval_insn(runtime, frame, insn)
+      case insn.code
+
+      when :f64_load
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        addr = runtime.stack.pop
+        if !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + F64.new.memsize / 8
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        buf = memory.data[at...data_end]
+        if !buf
+          raise EvalError, "invalid memory range"
+        end
+        runtime.stack.push(F64.from_bytes(buf))
+
+
+      when :f64_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 = runtime.stack.pop
+        addr = runtime.stack.pop
+        if !value.is_a?(F64) || !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + value.packed.size
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        memory.data[at...data_end] = value.packed
+
+
+      when :f64_const
+        const = insn.operand[0]
+        if !const.is_a?(Float)
+          raise EvalError, "invalid type of operand"
+        end
+        runtime.stack.push(F64(const))
+
+
+      when :f64_eqz
+        target = runtime.stack.pop
+        if !target.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = target.value.zero? ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f64_eq
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value == right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f64_ne
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value != right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f64_lt
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value < right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f64_gt
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value > right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f64_le
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value <= right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f64_ge
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value >= right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f64_abs
+        x = runtime.stack.pop
+        if !x.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(x.value.abs))
+
+
+      when :f64_neg
+        x = runtime.stack.pop
+        if !x.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(-(x.value)))
+
+
+      when :f64_ceil
+        x = runtime.stack.pop
+        if !x.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(x.value.ceil.to_f))
+
+
+      when :f64_floor
+        x = runtime.stack.pop
+        if !x.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(x.value.floor.to_f))
+
+
+      when :f64_trunc
+        x = runtime.stack.pop
+        if !x.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(x.value.to_i.to_f))
+
+
+      when :f64_nearest
+        x = runtime.stack.pop
+        if !x.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(x.value.round.to_f))
+
+
+      when :f64_sqrt
+        x = runtime.stack.pop
+        if !x.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(x.value ** 0.5))
+
+
+      when :f64_add
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(left.value + right.value))
+
+
+      when :f64_sub
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(left.value - right.value))
+
+
+      when :f64_mul
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(left.value * right.value))
+
+
+      when :f64_div
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F64(left.value / right.value))
+
+
+      when :f64_min
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        if right.value.nan? || left.value.nan?
+          runtime.stack.push(F64(Float::NAN))
+          return
+        end
+        runtime.stack.push(F64([left.value, right.value].min))
+
+
+      when :f64_max
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        if right.value.nan? || left.value.nan?
+          runtime.stack.push(F64(Float::NAN))
+          return
+        end
+        runtime.stack.push(F64([left.value, right.value].max))
+
+
+      when :f64_copysign
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F64) || !left.is_a?(F64)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        if left.sign == right.sign
+          runtime.stack.push(F64(left.value))
+        else
+          runtime.stack.push(F64(-left.value))
+        end
+
+
+      else
+        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+      end
+    end
+  end
+end

data/lib/wardite/alu_i32.generated.rb

@@ -10,7 +10,202 @@ module Wardite
     def self.i32_eval_insn(runtime, frame, insn)
       case insn.code
 
+      when :i32_load
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        addr = runtime.stack.pop
+        if !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + I32.new.memsize / 8
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        buf = memory.data[at...data_end]
+        if !buf
+          raise EvalError, "invalid memory range"
+        end
+        runtime.stack.push(I32.from_bytes(buf))
+
+
+      when :i32_load8_s
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        addr = runtime.stack.pop
+        if !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + 1
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        buf = memory.data[at...data_end]
+        if !buf
+          raise EvalError, "invalid memory range"
+        end
+        runtime.stack.push(I32.from_bytes(buf, size: 8, signed: true))
+
+
+      when :i32_load8_u
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        addr = runtime.stack.pop
+        if !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + 1
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        buf = memory.data[at...data_end]
+        if !buf
+          raise EvalError, "invalid memory range"
+        end
+        runtime.stack.push(I32.from_bytes(buf, size: 8, signed: false))
+
+
+      when :i32_load16_s
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        addr = runtime.stack.pop
+        if !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + 2
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        buf = memory.data[at...data_end]
+        if !buf
+          raise EvalError, "invalid memory range"
+        end
+        runtime.stack.push(I32.from_bytes(buf, size: 16, signed: true))
+
+
+      when :i32_load16_u
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        addr = runtime.stack.pop
+        if !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + 2
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        buf = memory.data[at...data_end]
+        if !buf
+          raise EvalError, "invalid memory range"
+        end
+        runtime.stack.push(I32.from_bytes(buf, size: 16, signed: false))
+
+
+      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 = runtime.stack.pop
+        addr = runtime.stack.pop
+        if !value.is_a?(I32) || !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + value.packed.size
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        memory.data[at...data_end] = value.packed
+
+
+      when :i32_store8
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        value = runtime.stack.pop
+        addr = runtime.stack.pop
+        if !value.is_a?(I32) || !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + 1
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        memory.data[at...data_end] = value.packed(size: 8)
+
+
+      when :i32_store16
+        _align = insn.operand[0] # TODO: alignment support?
+        offset = insn.operand[1]
+        raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
+      
+        value = runtime.stack.pop
+        addr = runtime.stack.pop
+        if !value.is_a?(I32) || !addr.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+      
+        at = addr.value + offset
+        data_end = at + 2
+        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
+        memory.data[at...data_end] = value.packed(size: 16)
+
+
+      when :i32_const
+        const = insn.operand[0]
+        if !const.is_a?(Integer)
+          raise EvalError, "invalid type of operand"
+        end
+        runtime.stack.push(I32(const))
+
+
+      when :i32_eqz
+        target = runtime.stack.pop
+        if !target.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = target.value.zero? ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_eq
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value == right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_ne
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value != right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
       when :i32_lts
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value_s < right.value_s) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_ltu
         right, left = runtime.stack.pop, runtime.stack.pop
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
@@ -19,7 +214,52 @@ module Wardite
         runtime.stack.push(I32(value))
 
 
+      when :i32_gts
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value_s > right.value_s) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_gtu
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value > right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_les
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value_s <= right.value_s) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
       when :i32_leu
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value <= right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_ges
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value_s >= right.value_s) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :i32_geu
         right, left = runtime.stack.pop, runtime.stack.pop
         if !right.is_a?(I32) || !left.is_a?(I32)
           raise EvalError, "maybe empty or invalid stack"
@@ -28,6 +268,56 @@ module Wardite
         runtime.stack.push(I32(value))
 
 
+      when :i32_clz
+        target = runtime.stack.pop
+        if !target.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        start = target.memsize - 1
+        count = 0
+        while start > -1
+          if (target.value >> start).zero?
+            count += 1
+            start -= 1
+          else
+            break
+          end
+        end
+        runtime.stack.push(I32(count))
+
+
+      when :i32_ctz
+        target = runtime.stack.pop
+        if !target.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        finish = target.memsize
+        count = 0
+        while count < finish
+          if (target.value & (1 << count)).zero?
+            count += 1
+          else
+            break
+          end
+        end
+        runtime.stack.push(I32(count))
+
+
+      when :i32_popcnt
+        target = runtime.stack.pop
+        if !target.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        digits = target.memsize
+        count = 0
+        digits.times do |i|
+          if (target.value & (1 << i)).zero?
+            count += 1
+          end
+        end
+        runtime.stack.push(I32(count))
+
+
       when :i32_add
         right, left = runtime.stack.pop, runtime.stack.pop
         if !right.is_a?(I32) || !left.is_a?(I32)
@@ -44,29 +334,119 @@ module Wardite
         runtime.stack.push(I32(left.value - right.value))
 
 
-      when :i32_const
-        const = insn.operand[0]
-        if !const.is_a?(Integer)
-          raise EvalError, "invalid type of operand"
+      when :i32_mul
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
         end
-        runtime.stack.push(I32(const))
+        runtime.stack.push(I32(left.value * right.value))
 
 
-      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 = runtime.stack.pop
-        addr = runtime.stack.pop
-        if !value.is_a?(I32) || !addr.is_a?(I32)
-          raise EvalError, "maybe stack too short"
+      when :i32_div_s
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value_s / right.value_s))
+
+
+      when :i32_div_u
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value / right.value))
+
+
+      when :i32_rem_s
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value_s % right.value_s))
+
+
+      when :i32_rem_u
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value % right.value))
+
+
+      when :i32_and
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value & right.value))
+
+
+      when :i32_or
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value | right.value))
+
+
+      when :i32_xor
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(I32(left.value ^ right.value))
+
+
+      when :i32_shl
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
         end
+        value = left.value << right.value
+        value %= (1 << right.memsize) 
       
-        at = addr.value + offset
-        data_end = at + value.packed.size
-        memory = runtime.instance.store.memories[0] || raise("[BUG] no memory")
-        memory.data[at...data_end] = value.packed
+        runtime.stack.push(I32(value))
+
+
+      when :i32_shr_s
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = left.value_s >> right.value
+        runtime.stack.push(I32(value))
+
+
+      when :i32_shr_u
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = left.value >> right.value
+        runtime.stack.push(I32(value))
+
+
+      when :i32_rotl
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        rotated = left.value << right.value
+        rest = left.value & (I32::I32_MAX << (right.memsize - right.value))
+        value = rotated | (rest >> (right.memsize - right.value))
+        runtime.stack.push(I32(value))
+
+
+      when :i32_rotr
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(I32) || !left.is_a?(I32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        rotated = left.value >> right.value
+        rest = left.value & (I32::I32_MAX >> (right.memsize - right.value))
+        value = rotated | (rest << (right.memsize - right.value))
+        runtime.stack.push(I32(value))
 
 
       else