wardite 0.2.0 → 0.2.1

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