wardite 0.2.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 932c8c0c36490c2b84b652ee4b43682ee0218c3d6ed4164685e5066b45e79e60
-  data.tar.gz: d185d75762ac744752fede64fe6fd766a4639105697af520eb01b802ae7bd4a2
+  metadata.gz: 2d2b7f37620b7290c9a4c1fc558024d87cb7ad73bf217c7f7abbda3e6dfda266
+  data.tar.gz: c239d24ee56a9dd80084abc11dcffad7a40edbc2c4644146c3cf91fa5b393ddd
 SHA512:
-  metadata.gz: 5251ca5fe770cfce8ad98f35ab31017b95d70d91e0088d640612c51f1506bb31e5484c26571cfc84503c686ab18f82a14b604698be5a0577072ef5dff6880cc7
-  data.tar.gz: f2c8f3e17ae79c3f79b9f736d3f31e317178cecacbc562900a592572596b283fdee1594267ccc3afb156426b7f7265a0d9ad9902bfc1a6a86e5f2db5622a9aa8
+  metadata.gz: 8a9369b5cb946190e8dd0f0fc5c17d383e9f5f168098332b78a4ed821398f0a6d7b631558ba6a8a32a14d9ebcce88dd23e8f05d32b73eb7d9e7aafa14a46b0f4
+  data.tar.gz: 62f7f961e035a39203616793aa257d238a62760c70f6c9184070d3b79cc0615b829fbe5c4b89608838efe3db6b1a9e26332a125530992fcb41dcd64df8df3304

data/Rakefile

@@ -170,6 +170,9 @@ task :generate do
       trunc_s: [:f32, :f64],
       trunc_u: [:f32, :f64],
       reinterpret: [:f32],
+      extendN_s: [:i8, :i16],
+      trunc_sat_s: [:f32, :f64],
+      trunc_sat_u: [:f32, :f64],
     },
     i64: {
       extend_s: [:i32, :i64],
@@ -177,6 +180,9 @@ task :generate do
       trunc_s: [:f32, :f64],
       trunc_u: [:f32, :f64],
       reinterpret: [:f64],
+      extendN_s: [:i8, :i16, :i32],
+      trunc_sat_s: [:f32, :f64],
+      trunc_sat_u: [:f32, :f64],
     },
     f32: {
       convert_s: [:i32, :i64],

data/examples/break.wat

@@ -0,0 +1,13 @@
+;; https://developer.mozilla.org/en-US/docs/WebAssembly/Reference/Control_flow/block
+(module
+  (func (export "ret_if_100") (param $num i32) (result i32)
+    (block $my_block
+      local.get $num
+      i32.const 100
+      i32.eq
+      (if
+        (then
+          br $my_block))
+      i32.const -1
+      local.set $num)
+    local.get $num))

data/examples/call_indirect.wat

@@ -0,0 +1,15 @@
+(module
+  ;; ref https://ukyo.github.io/wasm-usui-book/webroot/get-started-webassembly.html
+  ;; and https://developer.mozilla.org/ja/docs/WebAssembly/Understanding_the_text_format
+  (type $return_i32 (func (result i32)))
+  (table 3 funcref)
+  (elem (i32.const 0) $f1 $f2 $f3)
+
+  (func $f1 (result i32) i32.const 111)
+  (func $f2 (result i32) i32.const 222)
+  (func $f3 (result i32) i32.const 333)
+
+  (func (export "call_indirect") (param $i i32) (result i32)
+    local.get $i
+    call_indirect (type $return_i32))
+)

data/examples/loop.wat

@@ -0,0 +1,20 @@
+(module ;; https://developer.mozilla.org/en-US/docs/WebAssembly/Reference/Control_flow/br
+  (global $i (mut i32) (i32.const 0))
+
+  (func $count (result i32)
+    (loop $my_loop (result i32)
+      global.get $i
+      i32.const 1
+      i32.add
+      global.set $i
+
+      global.get $i
+      global.get $i
+      i32.const 10
+      i32.lt_s
+      br_if $my_loop
+    )
+  )
+
+  (export "count" (func $count))
+)

data/examples/memory_init.wat

@@ -0,0 +1,18 @@
+(module ;; 
+    (memory 1)
+    (data (i32.const 0) "hello") ;; data segment 0, is active so always copied
+    (data "goodbye")             ;; data segment 1, is passive
+
+    (func $start (param $test i32) (result i32)
+        (if (local.get $test)
+            (then (memory.init 1
+                (i32.const 16)
+                (i32.const 0)
+                (i32.const 7))
+                (return (i32.const 1))
+            )
+        )
+        (return (i32.const 0))
+    )
+    (export "test" (func $start))
+)

data/examples/saturate.wat

@@ -0,0 +1,8 @@
+(module
+  (global $big (mut f64) (f64.const 50000000000.0))
+  (func $main (result i32)
+    global.get $big
+    i32.trunc_sat_f64_s
+  )
+  (export "saturate" (func $main))
+)

data/examples/saturate_u.wat

@@ -0,0 +1,9 @@
+(module
+  (global $big (mut f64) (f64.const 50000000000.0))
+  (func $main (result i64)
+    global.get $big
+    i32.trunc_sat_f64_u
+    i64.extend_i32_u
+  )
+  (export "saturate" (func $main))
+)

data/examples/start.wat

@@ -0,0 +1,12 @@
+(module
+  (global $var (mut i32) (i32.const 0))
+  (func $init
+    i32.const 100
+    global.set $var
+  )
+  (func $main (result i32)
+    global.get $var ;; load $var onto the stack
+  )
+  (start $init)
+  (export "test" (func $main))
+)

data/lib/wardite/const.rb

@@ -3,18 +3,19 @@ module Wardite
   module Const
     # Section Code
     # @see https://www.w3.org/TR/wasm-core-1/#sections%E2%91%A0
-    SectionCustom   = 0x0 #: Integer
-    SectionType     = 0x1 #: Integer
-    SectionImport   = 0x2 #: Integer
-    SectionFunction = 0x3 #: Integer
-    SectionTable    = 0x4 #: Integer
-    SectionMemory   = 0x5 #: Integer
-    SectionGlobal   = 0x6 #: Integer
-    SectionExport   = 0x7 #: Integer
-    SectionStart    = 0x8 #: Integer
-    SectionElement  = 0x9 #: Integer
-    SectionCode     = 0xa #: Integer
-    SectionData     = 0xb #: Integer
+    SectionCustom    = 0x0 #: Integer
+    SectionType      = 0x1 #: Integer
+    SectionImport    = 0x2 #: Integer
+    SectionFunction  = 0x3 #: Integer
+    SectionTable     = 0x4 #: Integer
+    SectionMemory    = 0x5 #: Integer
+    SectionGlobal    = 0x6 #: Integer
+    SectionExport    = 0x7 #: Integer
+    SectionStart     = 0x8 #: Integer
+    SectionElement   = 0x9 #: Integer
+    SectionCode      = 0xa #: Integer
+    SectionData      = 0xb #: Integer
+    SectionDataCount = 0xc #: Integer
   end
   include Const
 end

data/lib/wardite/convert.generated.rb

@@ -58,6 +58,54 @@ module Wardite
         runtime.stack.push(to)
 
 
+      when :i32_extend_8_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(I32)
+        to = from.extendN_s(to: :i32, from: :i8)
+        raise EvalError, "failed to convert type" if !to.is_a?(I32)
+        runtime.stack.push(to)
+
+
+      when :i32_extend_16_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(I32)
+        to = from.extendN_s(to: :i32, from: :i16)
+        raise EvalError, "failed to convert type" if !to.is_a?(I32)
+        runtime.stack.push(to)
+
+
+      when :i32_trunc_sat_f32_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(F32)
+        to = from.trunc_sat_s(to: :i32)
+        raise EvalError, "failed to convert type" if !to.is_a?(I32)
+        runtime.stack.push(to)
+
+
+      when :i32_trunc_sat_f64_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(F64)
+        to = from.trunc_sat_s(to: :i32)
+        raise EvalError, "failed to convert type" if !to.is_a?(I32)
+        runtime.stack.push(to)
+
+
+      when :i32_trunc_sat_f32_u
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(F32)
+        to = from.trunc_sat_u(to: :i32)
+        raise EvalError, "failed to convert type" if !to.is_a?(I32)
+        runtime.stack.push(to)
+
+
+      when :i32_trunc_sat_f64_u
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(F64)
+        to = from.trunc_sat_u(to: :i32)
+        raise EvalError, "failed to convert type" if !to.is_a?(I32)
+        runtime.stack.push(to)
+
+
       when :i64_extend_i32_s
         from = runtime.stack.pop
         raise EvalError, "maybe empty or invalid stack" if !from.is_a?(I32)
@@ -130,6 +178,62 @@ module Wardite
         runtime.stack.push(to)
 
 
+      when :i64_extend_8_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(I32)
+        to = from.extendN_s(to: :i64, from: :i8)
+        raise EvalError, "failed to convert type" if !to.is_a?(I64)
+        runtime.stack.push(to)
+
+
+      when :i64_extend_16_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(I32)
+        to = from.extendN_s(to: :i64, from: :i16)
+        raise EvalError, "failed to convert type" if !to.is_a?(I64)
+        runtime.stack.push(to)
+
+
+      when :i64_extend_32_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(I32)
+        to = from.extendN_s(to: :i64, from: :i32)
+        raise EvalError, "failed to convert type" if !to.is_a?(I64)
+        runtime.stack.push(to)
+
+
+      when :i64_trunc_sat_f32_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(F32)
+        to = from.trunc_sat_s(to: :i64)
+        raise EvalError, "failed to convert type" if !to.is_a?(I64)
+        runtime.stack.push(to)
+
+
+      when :i64_trunc_sat_f64_s
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(F64)
+        to = from.trunc_sat_s(to: :i64)
+        raise EvalError, "failed to convert type" if !to.is_a?(I64)
+        runtime.stack.push(to)
+
+
+      when :i64_trunc_sat_f32_u
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(F32)
+        to = from.trunc_sat_u(to: :i64)
+        raise EvalError, "failed to convert type" if !to.is_a?(I64)
+        runtime.stack.push(to)
+
+
+      when :i64_trunc_sat_f64_u
+        from = runtime.stack.pop
+        raise EvalError, "maybe empty or invalid stack" if !from.is_a?(F64)
+        to = from.trunc_sat_u(to: :i64)
+        raise EvalError, "failed to convert type" if !to.is_a?(I64)
+        runtime.stack.push(to)
+
+
       when :f32_convert_i32_s
         from = runtime.stack.pop
         raise EvalError, "maybe empty or invalid stack" if !from.is_a?(I32)

data/lib/wardite/instruction.rb

@@ -1,6 +1,9 @@
 # rbs_inline: enabled
 
 module Wardite
+  # @rbs!
+  #   type operandItem = Integer | Array[Integer] | Float | Block
+
   class Op
     # @see https://pengowray.github.io/wasm-ops/
     SYMS = %i[
@@ -28,15 +31,27 @@ module Wardite
       i32_trunc_f32_s i32_trunc_f32_u i32_trunc_f64_s i32_trunc_f64_u i64_extend_i32_s i64_extend_i32_u i64_trunc_f32_s i64_trunc_f32_u
       i64_trunc_f64_s i64_trunc_f64_u f32_convert_i32_s f32_convert_i32_u f32_convert_i64_s f32_convert_i64_u f32_demote_f64 f64_convert_i32_s
       f64_convert_i32_u f64_convert_i64_s f64_convert_i64_u f64_promote_f32 i32_reinterpret_f32 i64_reinterpret_f64 f32_reinterpret_i32 f64_reinterpret_i64
+      i32_extend8_s i32_extend16_s i64_extend8_s i64_extend16_s i64_extend32_s
+      __unsuported_from_here_on__
+    ] #: Array[Symbol]
+
+    FC_SYMS = %i[
+      i32_trunc_sat_f32_s i32_trunc_sat_f32_u i32_trunc_sat_f64_s i32_trunc_sat_f64_u
+      i64_trunc_sat_f32_s i64_trunc_sat_f32_u i64_trunc_sat_f64_s i64_trunc_sat_f64_u
+      memory_init data_drop memory_copy memory_fill
+      table_init elem_drop table_copy table_grow
+      table_size table_fill
       __unsuported_from_here_on__
     ] #: Array[Symbol]
 
     # @rbs @@table: Hash[Integer, Symbol] | nil
-    @@table = nil 
+    @@table = nil
+    # @rbs @@table: Hash[Integer, Symbol] | nil
+    @@fc_table = nil
 
     # @rbs return: Hash[Integer, Symbol]
     def self.table
-      @@table if @@table != nil
+      return @@table if @@table != nil
       @@table = {}.tap do |ha|
         SYMS.each_with_index do |sym, i|
           ha[i] = sym
@@ -45,16 +60,27 @@ module Wardite
       @@table
     end
 
+    # @rbs return: Hash[Integer, Symbol]
+    def self.fc_table
+      return @@fc_table if @@fc_table != nil
+      @@fc_table = {}.tap do |ha|
+        FC_SYMS.each_with_index do |sym, i|
+          ha[i] = sym
+        end
+      end
+      @@fc_table
+    end
+    
     attr_accessor :namespace #: Symbol
 
     attr_accessor :code #: Symbol
 
     # TODO: add types of potential operands
-    attr_accessor :operand #: Array[Integer|Float|Block]
+    attr_accessor :operand #: Array[operandItem]
 
     # @rbs namespace: Symbol
     # @rbs code: Symbol
-    # @rbs operand: Array[Integer|Float|Block]
+    # @rbs operand: Array[operandItem]
     def initialize(namespace, code, operand)
       @namespace = namespace      
       @code = code
@@ -64,6 +90,10 @@ module Wardite
     # @rbs chr: String
     # @rbs return: [Symbol, Symbol]
     def self.to_sym(chr)
+      if chr.ord == 0xfc
+        return [:fc, :fc]
+      end
+
       code = table[chr.ord]
       if ! code
         raise "found unknown code 0x#{chr.ord.to_s(16)}"
@@ -82,6 +112,28 @@ module Wardite
       end
     end
 
+    # @rbs lower: Integer
+    # @rbs return: [Symbol, Symbol]
+    def self.resolve_fc_sym(lower)
+      if lower == 0xfc
+        return [:fc, :fc]
+      end
+
+      code = fc_table[lower]
+      if ! code
+        raise "found unknown code 0xfc 0x#{lower.to_s(16)}"
+      end
+
+      prefix = code.to_s.split("_")[0]
+      case prefix
+      when "i32", "i64", "f32", "f64"
+        # All FC operations for numeric are "convert"
+        [:convert, code]
+      else
+        [:default, code]
+      end
+    end
+
     # @rbs code: Symbol
     # @rbs return: Array[Symbol]
     def self.operand_of(code)
@@ -90,8 +142,12 @@ module Wardite
         [:u32, :u32]
       when :local_get, :local_set, :local_tee, :global_get, :global_set, :call, :br, :br_if
         [:u32]
+      when :memory_init, :memory_copy
+        [:u32, :u32]
+      when :memory_size, :memory_grow, :memory_fill
+        [:u32]
       when :call_indirect
-        [:u32, :u8]
+        [:u32, :u32]
       when :br_table
         [:u32_vec, :u32]
       when :i32_const
@@ -102,9 +158,7 @@ module Wardite
         [:f32]
       when :f64_const
         [:f64]
-      when :if
-        [:u8_if_block]
-      when :block, :loop
+      when :if, :block, :loop
         [:u8_block]
       else
         []
@@ -112,10 +166,15 @@ module Wardite
     end
 
     # @see https://www.w3.org/TR/wasm-core-1/#value-types%E2%91%A2
+    # We use this for reftype conversion. https://webassembly.github.io/spec/core/binary/types.html#binary-reftype
     # @rbs code: Integer
     # @rbs return: Symbol
     def self.i2type(code)
       case code
+      when 0x6f
+        :externref
+      when 0x70
+        :funcref
       when 0x7f
         :i32
       when 0x7e