wardite 0.8.1 → 0.9.0

data/examples/i32_bench_original.wat

@@ -0,0 +1,314 @@
+(module
+  ;; Export function that performs basic 4-operation arithmetic loop 10000 times
+  (func $arithmetic_loop (export "arithmetic_loop") (result i32)
+    (local $i i32)        ;; Loop counter
+    (local $a i32)        ;; Arithmetic variable a
+    (local $b i32)        ;; Arithmetic variable b
+    (local $result i32)   ;; Result storage
+    
+    ;; Initialize values
+    i32.const 0
+    local.set $i          ;; i = 0
+    
+    i32.const 10
+    local.set $a          ;; a = 10
+    
+    i32.const 3
+    local.set $b          ;; b = 3
+    
+    i32.const 0
+    local.set $result     ;; result = 0
+    
+    ;; Start loop
+    (loop $main_loop
+      ;; Addition: result += a + b
+      local.get $result
+      local.get $a
+      local.get $b
+      i32.add
+      i32.add
+      local.set $result
+      
+      ;; Subtraction: result += a - b
+      local.get $result
+      local.get $a
+      local.get $b
+      i32.sub
+      i32.add
+      local.set $result
+      
+      ;; Multiplication: result += a * b
+      local.get $result
+      local.get $a
+      local.get $b
+      i32.mul
+      i32.add
+      local.set $result
+      
+      ;; Division: result += a / b
+      local.get $result
+      local.get $a
+      local.get $b
+      i32.div_s
+      i32.add
+      local.set $result
+      
+      ;; Increment counter
+      local.get $i
+      i32.const 1
+      i32.add
+      local.set $i
+      
+      ;; Check loop continuation condition (i < 100000)
+      local.get $i
+      i32.const 100000
+      i32.lt_s
+      br_if $main_loop
+    )
+    
+    ;; Return result
+    local.get $result
+  )
+  
+  ;; Detailed 4-operation arithmetic function (execute each operation individually)
+  (func $detailed_arithmetic (export "detailed_arithmetic") (param $x i32) (param $y i32) (result i32)
+    (local $sum i32)
+    (local $diff i32)
+    (local $product i32)
+    (local $quotient i32)
+    (local $final_result i32)
+    
+    ;; Addition
+    local.get $x
+    local.get $y
+    i32.add
+    local.set $sum
+    
+    ;; Subtraction
+    local.get $x
+    local.get $y
+    i32.sub
+    local.set $diff
+    
+    ;; Multiplication
+    local.get $x
+    local.get $y
+    i32.mul
+    local.set $product
+    
+    ;; Division (with zero division check)
+    local.get $y
+    i32.const 0
+    i32.eq
+    (if
+      (then
+        i32.const 0
+        local.set $quotient
+      )
+      (else
+        local.get $x
+        local.get $y
+        i32.div_s
+        local.set $quotient
+      )
+    )
+    
+    ;; Sum all results
+    local.get $sum
+    local.get $diff
+    i32.add
+    local.get $product
+    i32.add
+    local.get $quotient
+    i32.add
+    local.set $final_result
+    
+    local.get $final_result
+  )
+  
+  ;; Execute detailed_arithmetic with changing numbers 10000 times
+  (func $detailed_arithmetic_loop (export "detailed_arithmetic_loop") (result i32)
+    (local $i i32)          ;; Loop counter
+    (local $x i32)          ;; First argument
+    (local $y i32)          ;; Second argument
+    (local $total_result i32) ;; Accumulated result
+    (local $current_result i32) ;; Current arithmetic result
+    
+    ;; Initialize values
+    i32.const 0
+    local.set $i            ;; i = 0
+    
+    i32.const 5
+    local.set $x            ;; x = 5 (initial value)
+    
+    i32.const 2
+    local.set $y            ;; y = 2 (initial value)
+    
+    i32.const 0
+    local.set $total_result ;; total_result = 0
+    
+    ;; Start loop
+    (loop $detailed_loop
+      ;; Call detailed_arithmetic function
+      local.get $x
+      local.get $y
+      call $detailed_arithmetic
+      local.set $current_result
+      
+      ;; Accumulate result
+      local.get $total_result
+      local.get $current_result
+      i32.add
+      local.set $total_result
+      
+      ;; Change x and y values (add variation)
+      ;; x = x + 1
+      local.get $x
+      i32.const 1
+      i32.add
+      local.set $x
+      
+      ;; y = (y * 2) % 17 + 1 (cycle in range 1-17, avoid zero division)
+      local.get $y
+      i32.const 2
+      i32.mul
+      i32.const 17
+      i32.rem_s
+      i32.const 1
+      i32.add
+      local.set $y
+      
+      ;; Limit x to prevent overflow (overflow protection)
+      local.get $x
+      i32.const 1000
+      i32.gt_s
+      (if
+        (then
+          i32.const 1
+          local.set $x
+        )
+      )
+      
+      ;; Increment counter
+      local.get $i
+      i32.const 1
+      i32.add
+      local.set $i
+      
+      ;; Check loop continuation condition (i < 100000)
+      local.get $i
+      i32.const 100000
+      i32.lt_s
+      br_if $detailed_loop
+    )
+    
+    ;; Return accumulated result
+    local.get $total_result
+  )
+  
+  ;; Version with more complex pattern for number changes
+  (func $detailed_arithmetic_complex_loop (export "detailed_arithmetic_complex_loop") (result i32)
+    (local $i i32)          ;; Loop counter
+    (local $x i32)          ;; First argument
+    (local $y i32)          ;; Second argument
+    (local $total_result i32) ;; Accumulated result
+    (local $current_result i32) ;; Current arithmetic result
+    
+    ;; Initialize values
+    i32.const 0
+    local.set $i            ;; i = 0
+    
+    i32.const 10
+    local.set $x            ;; x = 10 (initial value)
+    
+    i32.const 3
+    local.set $y            ;; y = 3 (initial value)
+    
+    i32.const 0
+    local.set $total_result ;; total_result = 0
+    
+    ;; Start loop
+    (loop $complex_loop
+      ;; Call detailed_arithmetic function
+      local.get $x
+      local.get $y
+      call $detailed_arithmetic
+      local.set $current_result
+      
+      ;; Accumulate result
+      local.get $total_result
+      local.get $current_result
+      i32.add
+      local.set $total_result
+      
+      ;; Change numbers with more complex pattern
+      ;; x = (x + i) % 100 + 1 (range 1-100)
+      local.get $x
+      local.get $i
+      i32.add
+      i32.const 100
+      i32.rem_s
+      i32.const 1
+      i32.add
+      local.set $x
+      
+      ;; y = (i * 3 + 7) % 13 + 1 (range 1-13, avoid zero division)
+      local.get $i
+      i32.const 3
+      i32.mul
+      i32.const 7
+      i32.add
+      i32.const 13
+      i32.rem_s
+      i32.const 1
+      i32.add
+      local.set $y
+      
+      ;; Increment counter
+      local.get $i
+      i32.const 1
+      i32.add
+      local.set $i
+      
+      ;; Check loop continuation condition (i < 100000)
+      local.get $i
+      i32.const 100000
+      i32.lt_s
+      br_if $complex_loop
+    )
+    
+    ;; Return accumulated result
+    local.get $total_result
+  )
+
+  ;; Floating-point 4-operation arithmetic (f32)
+  (func $float_arithmetic (export "float_arithmetic") (param $x f32) (param $y f32) (result f32)
+    (local $result f32)
+    
+    ;; Addition
+    local.get $x
+    local.get $y
+    f32.add
+    
+    ;; Add subtraction
+    local.get $x
+    local.get $y
+    f32.sub
+    f32.add
+    
+    ;; Add multiplication
+    local.get $x
+    local.get $y
+    f32.mul
+    f32.add
+    
+    ;; Add division
+    local.get $x
+    local.get $y
+    f32.div
+    f32.add
+    
+    local.set $result
+    local.get $result
+  )
+)

data/examples/load_perf.rb

@@ -0,0 +1,24 @@
+require "wardite"
+require "optparse"
+require "ostruct"
+
+$options = OpenStruct.new
+
+opt = OptionParser.new
+opt.on('--wasm-file [FILE]') {|v| $options.wasm_file = v }
+opt.parse!
+
+f = File.open($options.wasm_file)
+
+require "vernier"
+RubyVM::YJIT.enable
+puts "YJIT enabled: #{RubyVM::YJIT.enabled?}"
+
+Vernier.profile(out: "./tmp/load_perf.json") do
+  start = Time.now
+  _instance = Wardite::BinaryLoader::load_from_buffer(f);
+  puts "Profile saved to ./tmp/load_perf.json"
+  puts "Load time: #{Time.now.to_f - start.to_f} seconds"
+end
+
+p "OK"

data/lib/wardite/alu_f32.generated.rb

@@ -5,14 +5,15 @@ 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
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.f32_eval_insn(runtime, frame, code, operand)
+      case code
 
       when :f32_load
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -31,8 +32,8 @@ module Wardite
 
 
       when :f32_store
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -48,7 +49,7 @@ module Wardite
 
 
       when :f32_const
-        const = insn.operand[0]
+        const = operand[0]
         if !const.is_a?(Float)
           raise EvalError, "invalid type of operand"
         end
@@ -243,8 +244,9 @@ module Wardite
 
 
       else
-        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+        return
       end
+      return true
     end
   end
 end

data/lib/wardite/alu_f64.generated.rb

@@ -5,14 +5,15 @@ 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
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.f64_eval_insn(runtime, frame, code, operand)
+      case code
 
       when :f64_load
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -31,8 +32,8 @@ module Wardite
 
 
       when :f64_store
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -48,7 +49,7 @@ module Wardite
 
 
       when :f64_const
-        const = insn.operand[0]
+        const = operand[0]
         if !const.is_a?(Float)
           raise EvalError, "invalid type of operand"
         end
@@ -243,8 +244,9 @@ module Wardite
 
 
       else
-        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+        return
       end
+      return true
     end
   end
 end

data/lib/wardite/alu_i32.generated.rb

@@ -5,14 +5,15 @@ module Wardite
   module Evaluator
     # @rbs runtime: Runtime
     # @rbs frame: Frame
-    # @rbs insn: Op
-    # @rbs return: void 
-    def self.i32_eval_insn(runtime, frame, insn)
-      case insn.code
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.i32_eval_insn(runtime, frame, code, operand)
+      case code
 
       when :i32_load
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -31,8 +32,8 @@ module Wardite
 
 
       when :i32_load8_s
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -51,8 +52,8 @@ module Wardite
 
 
       when :i32_load8_u
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -71,8 +72,8 @@ module Wardite
 
 
       when :i32_load16_s
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -91,8 +92,8 @@ module Wardite
 
 
       when :i32_load16_u
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -111,8 +112,8 @@ module Wardite
 
 
       when :i32_store
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -128,8 +129,8 @@ module Wardite
 
 
       when :i32_store8
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -145,8 +146,8 @@ module Wardite
 
 
       when :i32_store16
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -162,7 +163,7 @@ module Wardite
 
 
       when :i32_const
-        const = insn.operand[0]
+        const = operand[0]
         if !const.is_a?(Integer)
           raise EvalError, "invalid type of operand"
         end
@@ -464,8 +465,9 @@ module Wardite
 
 
       else
-        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+        return
       end
+      return true
     end
   end
 end

data/lib/wardite/alu_i64.generated.rb

@@ -5,14 +5,15 @@ module Wardite
   module Evaluator
     # @rbs runtime: Runtime
     # @rbs frame: Frame
-    # @rbs insn: Op
-    # @rbs return: void 
-    def self.i64_eval_insn(runtime, frame, insn)
-      case insn.code
+    # @rbs code: Symbol
+    # @rbs operand: Array[operandItem]
+    # @rbs return: bool?
+    def self.i64_eval_insn(runtime, frame, code, operand)
+      case code
 
       when :i64_load
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -31,8 +32,8 @@ module Wardite
 
 
       when :i64_load8_s
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -51,8 +52,8 @@ module Wardite
 
 
       when :i64_load8_u
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -71,8 +72,8 @@ module Wardite
 
 
       when :i64_load16_s
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -91,8 +92,8 @@ module Wardite
 
 
       when :i64_load16_u
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -111,8 +112,8 @@ module Wardite
 
 
       when :i64_load32_s
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -131,8 +132,8 @@ module Wardite
 
 
       when :i64_load32_u
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         addr = runtime.stack.pop
@@ -151,8 +152,8 @@ module Wardite
 
 
       when :i64_store
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -168,8 +169,8 @@ module Wardite
 
 
       when :i64_store8
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -185,8 +186,8 @@ module Wardite
 
 
       when :i64_store16
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -202,8 +203,8 @@ module Wardite
 
 
       when :i64_store32
-        _align = insn.operand[0] # TODO: alignment support?
-        offset = insn.operand[1]
+        _align = operand[0] # TODO: alignment support?
+        offset = operand[1]
         raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
       
         value = runtime.stack.pop
@@ -219,7 +220,7 @@ module Wardite
 
 
       when :i64_const
-        const = insn.operand[0]
+        const = operand[0]
         if !const.is_a?(Integer)
           raise EvalError, "invalid type of operand"
         end
@@ -521,8 +522,9 @@ module Wardite
 
 
       else
-        raise "Unknown opcode for namespace #{insn.namespace}: #{insn.code}"
+        return
       end
+      return true
     end
   end
 end