wardite 0.1.2 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d27a05a105bd446883460d42c05cbec8502360dc686098368d59b1ae5e6e3e91
-  data.tar.gz: d17f48eade8ac57845bf250583db7eb33dd9a418c315ba1083a7e0f598505298
+  metadata.gz: cefed459056cdf59c5c8823b1b4ef8ff53c84fd09a9f73883aaa291561ba4e00
+  data.tar.gz: b4ac97c31de3cc655aaf68d9c2097d1cb73ff67a184fd0c365d99b36371f1f93
 SHA512:
-  metadata.gz: 21de2c67fd7aaaf04d55f028d304588a4f5c7f92b21ab4b7cb40dd7882103067db85401f41efc53b491996a82f109a9b11c05b0efa62e9622ad3971f6e254342
-  data.tar.gz: 90542ce81cf6bf537eac6ddab087abab10842bfb24f153ba88865a7d2b5a0417c3e3fbab116e5ad2bedabc3d665810f34c0c8568a2baa2adbbdda89c681df076
+  metadata.gz: b3987aab13095263b109e7c907bee2640c3b9d2a5777b1b81812f692508de160d7fdd9f28e8c19c25d53445905e3b7b65379e0443f36dd56232e5c61b7d054bc
+  data.tar.gz: ca3e1e1b0390869ce69ddc880e574ff3fb6c75c7def7538ad628c121ea5c12e1c860dbadc960cbaba48841f6ab5be3f1eeb117e0822dd9488271eab0eb1745d9

data/Rakefile

@@ -15,5 +15,183 @@ task :check do
   sh "bundle exec steep check"
 end
 
+desc "Compile wat"
+task :wasm, [:name] do |t, args|
+  Dir.chdir "examples" do
+    sh "wat2wasm #{args.name}.wat"
+  end
+end
+
+desc "Generate codes"
+task :generate do
+  require_relative "scripts/gen_alu"
+  require_relative "scripts/gen_conv"
+  libdir = File.expand_path("../lib", __FILE__)
+
+  GenAlu.execute(libdir + "/wardite/alu_i32.generated.rb", prefix: "i32", defined_ops: [
+    :load,
+    :load8_s,
+    :load8_u,
+    :load16_s,
+    :load16_u,
+    :store,
+    :store8,
+    :store16,
+    :const,
+    :eqz,
+    :eq,
+    :ne,
+    :lts,
+    :ltu,
+    :gts,
+    :gtu,
+    :les,
+    :leu,
+    :ges,
+    :geu,
+    :clz,
+    :ctz,
+    :popcnt,
+    :add,
+    :sub,
+    :mul,
+    :div_s,
+    :div_u,
+    :rem_s,
+    :rem_u,
+    :and,
+    :or,
+    :xor,
+    :shl,
+    :shr_s,
+    :shr_u,
+    :rotl,
+    :rotr,
+  ])
+  GenAlu.execute(libdir + "/wardite/alu_i64.generated.rb", prefix: "i64", defined_ops: [
+    :load,
+    :load8_s,
+    :load8_u,
+    :load16_s,
+    :load16_u,
+    :load32_s,
+    :load32_u,
+    :store,
+    :store8,
+    :store16,
+    :store32,
+    :const,
+    :eqz,
+    :eq,
+    :ne,
+    :lts,
+    :ltu,
+    :gts,
+    :gtu,
+    :les,
+    :leu,
+    :ges,
+    :geu,
+    :clz,
+    :ctz,
+    :popcnt,
+    :add,
+    :sub,
+    :mul,
+    :div_s,
+    :div_u,
+    :rem_s,
+    :rem_u,
+    :and,
+    :or,
+    :xor,
+    :shl,
+    :shr_s,
+    :shr_u,
+    :rotl,
+    :rotr,
+  ])
+  GenAlu.execute(libdir + "/wardite/alu_f32.generated.rb", prefix: "f32", defined_ops: [
+    :load,
+    :store,
+    :const__f,
+    :eqz,
+    :eq,
+    :ne,
+    :lt,
+    :gt,
+    :le,
+    :ge,
+    :abs,
+    :neg,
+    :ceil,
+    :floor,
+    :trunc,
+    :nearest,
+    :sqrt,
+    :add,
+    :sub,
+    :mul,
+    :div,
+    :min,
+    :max,
+    :copysign,
+  ])
+  GenAlu.execute(libdir + "/wardite/alu_f64.generated.rb", prefix: "f64", defined_ops: [
+    :load,
+    :store,
+    :const__f,
+    :eqz,
+    :eq,
+    :ne,
+    :lt,
+    :gt,
+    :le,
+    :ge,
+    :abs,
+    :neg,
+    :ceil,
+    :floor,
+    :trunc,
+    :nearest,
+    :sqrt,
+    :add,
+    :sub,
+    :mul,
+    :div,
+    :min,
+    :max,
+    :copysign,
+  ])
+
+  GenConv.execute(libdir + "/wardite/convert.generated.rb", defined_ops: {
+    i32: {
+      wrap: [:i64],
+      trunc_s: [:f32, :f64],
+      trunc_u: [:f32, :f64],
+      reinterpret: [:f32],
+    },
+    i64: {
+      extend_s: [:i32, :i64],
+      extend_u: [:i32, :i64],
+      trunc_s: [:f32, :f64],
+      trunc_u: [:f32, :f64],
+      reinterpret: [:f64],
+    },
+    f32: {
+      convert_s: [:i32, :i64],
+      convert_u: [:i32, :i64],
+      demote: [:f64],
+      reinterpret: [:i32],
+    },
+    f64: {
+      convert_s: [:i32, :i64],
+      convert_u: [:i32, :i64],
+      promote: [:f32],
+      reinterpret: [:i64],
+    },
+  })
+end
+
 task default: %i[test check]
 

data/Steepfile

@@ -3,6 +3,7 @@ target :lib do
   signature "sig"
   check "lib"
 
+  library "pp"
   # configure_code_diagnostics(Steep::Diagnostic::Ruby.strict)
 end
 

data/examples/consts.wat

@@ -0,0 +1,12 @@
+(module
+  (func $test_const (result f32)
+    (i32.const 42)
+    (drop)
+    (i64.const 42)
+    (drop)
+    (f64.const 3.14)
+    (drop)
+    (f32.const 3.14)
+  )
+  (export "test_const" (func $test_const))
+)

data/lib/wardite/alu_f32.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.f32_eval_insn(runtime, frame, insn)
+      case insn.code
+
+      when :f32_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 + F32.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(F32.from_bytes(buf))
+
+
+      when :f32_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?(F32) || !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 :f32_const
+        const = insn.operand[0]
+        if !const.is_a?(Float)
+          raise EvalError, "invalid type of operand"
+        end
+        runtime.stack.push(F32(const))
+
+
+      when :f32_eqz
+        target = runtime.stack.pop
+        if !target.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = target.value.zero? ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f32_eq
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value == right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f32_ne
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value != right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f32_lt
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value < right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f32_gt
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value > right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f32_le
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value <= right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f32_ge
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        value = (left.value >= right.value) ? 1 : 0
+        runtime.stack.push(I32(value))
+
+
+      when :f32_abs
+        x = runtime.stack.pop
+        if !x.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(x.value.abs))
+
+
+      when :f32_neg
+        x = runtime.stack.pop
+        if !x.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(-(x.value)))
+
+
+      when :f32_ceil
+        x = runtime.stack.pop
+        if !x.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(x.value.ceil.to_f))
+
+
+      when :f32_floor
+        x = runtime.stack.pop
+        if !x.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(x.value.floor.to_f))
+
+
+      when :f32_trunc
+        x = runtime.stack.pop
+        if !x.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(x.value.to_i.to_f))
+
+
+      when :f32_nearest
+        x = runtime.stack.pop
+        if !x.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(x.value.round.to_f))
+
+
+      when :f32_sqrt
+        x = runtime.stack.pop
+        if !x.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(x.value ** 0.5))
+
+
+      when :f32_add
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(left.value + right.value))
+
+
+      when :f32_sub
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(left.value - right.value))
+
+
+      when :f32_mul
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(left.value * right.value))
+
+
+      when :f32_div
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        runtime.stack.push(F32(left.value / right.value))
+
+
+      when :f32_min
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        if right.value.nan? || left.value.nan?
+          runtime.stack.push(F32(Float::NAN))
+          return
+        end
+        runtime.stack.push(F32([left.value, right.value].min))
+
+
+      when :f32_max
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        if right.value.nan? || left.value.nan?
+          runtime.stack.push(F32(Float::NAN))
+          return
+        end
+        runtime.stack.push(F32([left.value, right.value].max))
+
+
+      when :f32_copysign
+        right, left = runtime.stack.pop, runtime.stack.pop
+        if !right.is_a?(F32) || !left.is_a?(F32)
+          raise EvalError, "maybe empty or invalid stack"
+        end
+        if left.sign == right.sign
+          runtime.stack.push(F32(left.value))
+        else
+          runtime.stack.push(F32(-left.value))
+        end
+
+
+      else
+        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+      end
+    end
+  end
+end

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