wardite 0.3.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f92001daa1c57ae535fd1556fabee90a61dbe741e4e5b9f313c26e5d75d68b3e
-  data.tar.gz: 237df98e70875e1b6e69fbf0019cc298c3df26fa69cd4e62df8a04eaeff37522
+  metadata.gz: '02079b17ada50d21f00ea34c1830452eea21ff12a2fb6e9c5903d07cdca53d3a'
+  data.tar.gz: 9ab24caf2cc630593ce32ab652c8044a621f67ddce1cb70f75a1cd9e767b13e2
 SHA512:
-  metadata.gz: 94b5d318cebff3c8d87ea03fa0c5489ece3ef26ca7fcd6e6324febaf55a63f0a9ecb0a76d01b5adf5712737d8daf79ac55f5e2149ff8f85612acbaee1a2ace8c
-  data.tar.gz: c5991f43b9a62a7df87f23ec71350a77bf9493ccd083c6d0dba596c55976460e0c89625294048389a5fec1e35826bfbddd205718b45e04353b8e1627ccc4bb57
+  metadata.gz: 88054ffba3884002ea3ff7c63b21a38ff41a93f2e641ec7b82cf39f47e7df7672c5c6412f4efd1ca9feb6e222aaaadf98e67a40810c8ed213046df348aac8f79
+  data.tar.gz: 1c5b8765bff6ae42eb00c696efd8af2c6b892911d52fc68a1124fb3804419f121f886ba416b6b39b3183afa22e1f6aadf730681c004f254796c5e6934ab39da1

data/README.md

@@ -7,6 +7,21 @@ A pure-ruby webassembly runtime.
 - [x] Fully typed by RBS (with the aid of [rbs-inline](https://github.com/soutaro/rbs-inline))
 - [ ] WASI (p1) support
 
+## Supported Instructions
+
+ref: https://webassembly.github.io/spec/core/binary/instructions.html
+
+- [x] Control Instructions
+- [x] Parametric Instructions
+- [x] Variable Instructions
+- [ ] Table Instructions
+- [x] Memory Instructions (except `data.drop`)
+- [x] Numeric Instructions (`0x41 ... 0xC4`)
+- [x] Numeric Instructions (`0xFC` Operations)
+- [ ] Reference Instructions
+- [ ] Vector Instructions
+- [x] end `0x0B`
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

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/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/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

@@ -31,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
     # @rbs @@table: Hash[Integer, Symbol] | nil
-    @@table = 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
@@ -48,6 +60,17 @@ 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
@@ -67,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)}"
@@ -85,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)
@@ -93,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

data/lib/wardite/leb128.rb

@@ -2,8 +2,9 @@
 module Wardite
   module Leb128Helper
     # @rbs buf: File|StringIO
+    # @rbs max_level: Integer
     # @rbs return: Integer
-    def fetch_uleb128(buf)
+    def fetch_uleb128(buf, max_level: 8)
       dest = 0
       level = 0
       while b = buf.read(1)
@@ -18,7 +19,7 @@ module Wardite
           return dest
         end
 
-        if level > 6
+        if level > max_level
           break
         end
         level += 1
@@ -29,7 +30,7 @@ module Wardite
 
     # @rbs buf: File|StringIO
     # @rbs return: Integer
-    def fetch_sleb128(buf)
+    def fetch_sleb128(buf, max_level: 8)
       dest = 0
       level = 0
       while b = buf.read(1)
@@ -44,7 +45,7 @@ module Wardite
           break
         end
 
-        if level > 6
+        if level > max_level
           raise "unreachable! debug: dest = #{dest} level = #{level}"
         end
         level += 1

data/lib/wardite/load.rb

@@ -148,7 +148,9 @@ module Wardite
 
   class DataSection < Section
     class Segment
-      attr_accessor :flags #: Integer
+      attr_accessor :mode #: :active|:passive
+
+      attr_accessor :mem_index #: Integer
       
       attr_accessor :offset #: Integer
 
@@ -172,6 +174,19 @@ module Wardite
     end
   end
 
+  class DataCountSection < Section
+    attr_accessor :count #: Integer
+
+    # @rbs count: Integer
+    # @rbs return: void
+    def initialize(count)
+      self.name = "Data"
+      self.code = 0xc
+
+      @count = count
+    end
+  end
+
   class ExportSection < Section
     class ExportDesc
       attr_accessor :name #: String
@@ -310,6 +325,8 @@ module Wardite
             code_section
           when Wardite::SectionData
             data_section
+          when Wardite::Const::SectionDataCount
+            data_count_section
           when Wardite::SectionCustom
             unimplemented_skip_section(code)
           else
@@ -590,7 +607,7 @@ module Wardite
     def self.code_body(buf)
       dest = []
       while c = buf.read(1)
-        namespace, code = Op.to_sym(c)
+        namespace, code = resolve_code(c, buf)
         operand_types = Op.operand_of(code)
         operand = [] #: Array[operandItem]
         operand_types.each do |typ|
@@ -613,7 +630,7 @@ module Wardite
           when :i32
             operand << fetch_sleb128(buf)
           when :i64
-            operand << fetch_sleb128(buf)
+            operand << fetch_sleb128(buf, max_level: 16)
           when :f32
             data = buf.read 4
             if !data || data.size != 4
@@ -650,6 +667,24 @@ module Wardite
       end
 
       dest
+    rescue => e
+      require "pp"
+      $stderr.puts "parsed:::"
+      $stderr.puts "#{dest.pretty_inspect}"
+      $stderr.puts "code = #{code}"
+      raise e
+    end
+
+    # @rbs c: String
+    # @rbs buf: StringIO
+    # @rbs return: [Symbol, Symbol]
+    def self.resolve_code(c, buf)
+      namespace, code = Op.to_sym(c)
+      if namespace == :fc
+        lower = fetch_uleb128(buf)
+        return Op.resolve_fc_sym(lower) #: [Symbol, Symbol]
+      end
+      return [namespace, code] #: [Symbol, Symbol]
     end
 
     # @rbs return: DataSection
@@ -661,27 +696,54 @@ module Wardite
 
       len = fetch_uleb128(sbuf)
       len.times do |i|
-        mem_index = fetch_uleb128(sbuf)
-        code = fetch_insn_while_end(sbuf)
-        ops = code_body(StringIO.new(code))
-        offset = decode_expr(ops)
-
-        len = fetch_uleb128(sbuf)
-        data = sbuf.read len
-        if !data
-          raise LoadError, "buffer too short"
-        end
-
-        segment = DataSection::Segment.new do |seg|
-          seg.flags = mem_index
-          seg.offset = offset
-          seg.data = data
+        data_type = fetch_uleb128(sbuf)
+        case data_type
+        when 0x0
+          # active
+          code = fetch_insn_while_end(sbuf)
+          ops = code_body(StringIO.new(code))
+          offset = decode_expr(ops)
+          len = fetch_uleb128(sbuf)
+          data = sbuf.read len
+          if !data
+            raise LoadError, "buffer too short"
+          end
+          segment = DataSection::Segment.new do |seg|
+            seg.mode = :active
+            seg.mem_index = 0 # memory index
+            seg.offset = offset
+            seg.data = data
+          end
+          dest.segments << segment
+        when 0x1
+          # passive
+          dsize = fetch_uleb128(sbuf)
+          data = sbuf.read dsize
+          if !data
+            raise LoadError, "data too short"
+          end
+          segment = DataSection::Segment.new do |seg|
+            seg.mode = :passive
+            seg.mem_index = 0 # unused
+            seg.offset = 0 # unused
+            seg.data = data
+          end
+          dest.segments << segment
         end
-        dest.segments << segment
       end
       dest
     end
 
+    # @rbs return: DataCountSection
+    def self.data_count_section
+      size = fetch_uleb128(@buf)
+      sbuf = StringIO.new(@buf.read(size) || raise("buffer too short"))
+      count = fetch_uleb128(sbuf)
+      dest = DataCountSection.new(count)
+      dest.size = size
+      dest
+    end
+
     # @rbs sbuf: StringIO
     # @rbs return: String
     def self.fetch_insn_while_end(sbuf)
@@ -740,7 +802,18 @@ module Wardite
           raise "Invalid definition of operand"
         end
         return I64(arg)
-      # TODO: floats
+      when :f32_const
+        arg = op.operand[0]
+        if !arg.is_a?(Float)
+          raise "Invalid definition of operand"
+        end
+        return F32(arg)
+      when :f64_const
+        arg = op.operand[0]
+        if !arg.is_a?(Float)
+          raise "Invalid definition of operand"
+        end
+        return F64(arg)
       else
         raise "Unimplemented offset op: #{op.code.inspect}"
       end
@@ -778,7 +851,7 @@ module Wardite
     # @rbs return: nil
     def self.unimplemented_skip_section(code)
       $stderr.puts "warning: unimplemented section: 0x0#{code}"
-      size = @buf.read(1)&.ord
+      size = fetch_uleb128(@buf)
       @buf.read(size)
       nil
     end

data/lib/wardite/value.rb

@@ -56,7 +56,7 @@ module Wardite
   class I32
     include ValueHelper
 
-    I32_MAX = (1<<32) - 1
+    I32_MAX = (1<<32) - 1 #: Integer
     # value should be stored as unsigned Integer, even in I32/I64
     # when we want to access signed value, it'd be done via #value_s
     attr_accessor :value #: Integer
@@ -190,6 +190,49 @@ module Wardite
       F32(v)
     end
 
+    # @rbs from: Symbol
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def extendN_s(from:, to:)
+      src_value = case from
+      when :i8
+        base = value & 0xff
+        (base >> 8).zero? ?
+          base :
+          ((-base) ^ 0xff) + 1
+      when :i16
+        base = value & 0xffff
+        (base >> 15).zero? ?
+          base :
+          ((-base) ^ 0xffff) + 1
+      when :i32
+        value_s
+      else
+        raise EvalError, "unsupported value size"
+      end
+
+      case to
+      when :i32
+        I32(src_value)
+      when :i64
+        I64(src_value)
+      else
+        raise EvalError, "unsupported value size"
+      end
+    end
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_u(to:)
+      raise EvalError, "unsupported operation"
+    end
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_s(to:)
+      raise EvalError, "unsupported operation"
+    end
+
     # I32#inspect shows signed value for convinience
     def inspect
       "I32(#{value_s})"
@@ -199,7 +242,7 @@ module Wardite
   class I64
     include ValueHelper
 
-    I64_MAX = (1<<64) - 1
+    I64_MAX = (1<<64) - 1 #: Integer
 
     attr_accessor :value #: Integer
 
@@ -334,6 +377,25 @@ module Wardite
       F32(v)
     end
 
+    # @rbs from: Symbol
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def extendN_s(from:, to:)
+      raise EvalError, "unsupported operation"
+    end
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_u(to:)
+      raise EvalError, "unsupported operation"
+    end
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_s(to:)
+      raise EvalError, "unsupported operation"
+    end
+
     # I64#inspect shows signed value
     def inspect
       "I64(#{@value})"
@@ -395,28 +457,52 @@ module Wardite
 
     # @todo need more testcase...
     # @see https://webassembly.github.io/spec/core/exec/numerics.html#xref-exec-numerics-op-trunc-s-mathrm-trunc-mathsf-s-m-n-z
+    # @see copy this impl to F64 when changed
     # @rbs to: Symbol
+    # @rbs saturating: bool
     # @rbs return: wasmValue
-    def trunc_s(to:)
+    def trunc_s(to:, saturating: false)
       v = value.to_i
       case to
       when :i32
         if v >= 0
-          I32(v & (I32::I32_MAX >> 1))
+          i32_signed_max = I32::I32_MAX >> 1
+          if saturating
+            v = i32_signed_max if v > i32_signed_max
+          else
+            v = v & i32_signed_max
+          end
+          I32(v & i32_signed_max)
         else
-          v = v & I32::I32_MAX
-          if (v >> 31).zero?
-            raise EvalError, "[undefined behavior] detected overflow: #{value}"
+          i32_signed_min = -(I32::I32_MAX >> 1) - 1
+          if saturating
+            v = i32_signed_min if v < i32_signed_min
+          else
+            v = v & I32::I32_MAX
+            if (v >> 31).zero?
+              raise EvalError, "[undefined behavior] detected overflow: #{value}"
+            end
           end
           I32(v)
         end
       when :i64
         if v >= 0
-          I64(v & (I64::I64_MAX >> 1))
+          i64_signed_max = I64::I64_MAX >> 1
+          if saturating
+            v = i64_signed_max if v > i64_signed_max
+          else
+            v = v & i64_signed_max
+          end
+          I64(v & i64_signed_max)
         else
-          v = v & I64::I64_MAX
-          if (v >> 31).zero?
-            raise EvalError, "[undefined behavior] detected overflow: #{value}"
+          i64_signed_min = -(I64::I64_MAX >> 1) - 1
+          if saturating
+            v = i64_signed_min if v < i64_signed_min
+          else
+            v = v & I64::I64_MAX
+            if (v >> 63).zero?
+              raise EvalError, "[undefined behavior] detected overflow: #{value}"
+            end
           end
           I64(v)
         end
@@ -426,19 +512,33 @@ module Wardite
     end
 
     # @see https://webassembly.github.io/spec/core/exec/numerics.html#xref-exec-numerics-op-trunc-u-mathrm-trunc-mathsf-u-m-n-z
+    # @see copy this impl to F64 when changed
     # @rbs to: Symbol
+    # @rbs sturating: bool
     # @rbs return: wasmValue
-    def trunc_u(to:)
+    def trunc_u(to:, saturating: false)
       v = value.to_i
       if v < 0
-        raise EvalError, "[undefined behavior] unexpected negative value"
+        if saturating
+          v = 0
+        else
+          raise EvalError, "[undefined behavior] unexpected negative value"
+        end
       end
       case to
       when :i32
-        v = v & I32::I32_MAX
+        if saturating
+          v = I32::I32_MAX if v > I32::I32_MAX
+        else
+          v = v & I32::I32_MAX
+        end
         I32(v)
       when :i64
-        v = v & I64::I64_MAX
+        if saturating
+          v = I64::I64_MAX if v > I64::I64_MAX
+        else
+          v = v & I64::I64_MAX
+        end
         I64(v)
       else
         raise EvalError, "unsupported operation to: #{to}"
@@ -479,6 +579,25 @@ module Wardite
       I32(v)
     end
 
+    # @rbs from: Symbol
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def extendN_s(from:, to:)
+      raise EvalError, "unsupported operation"
+    end
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_u(to:)
+      trunc_u(to: to, saturating: true)
+    end
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_s(to:)
+      trunc_s(to: to, saturating: true)
+    end
+
     def inspect
       "F32(#{@value})"
     end
@@ -539,27 +658,50 @@ module Wardite
 
     # @see the same as F32
     # @rbs to: Symbol
+    # @rbs saturating: bool
     # @rbs return: wasmValue
-    def trunc_s(to:)
+    def trunc_s(to:, saturating: false)
       v = value.to_i
       case to
       when :i32
         if v >= 0
-          I32(v & (I32::I32_MAX >> 1))
+          i32_signed_max = I32::I32_MAX >> 1
+          if saturating
+            v = i32_signed_max if v > i32_signed_max
+          else
+            v = v & i32_signed_max
+          end
+          I32(v & i32_signed_max)
         else
-          v = v & I32::I32_MAX
-          if (v >> 31).zero?
-            raise EvalError, "[undefined behavior] detected overflow: #{value}"
+          i32_signed_min = -(I32::I32_MAX >> 1) - 1
+          if saturating
+            v = i32_signed_min if v < i32_signed_min
+          else
+            v = v & I32::I32_MAX
+            if (v >> 31).zero?
+              raise EvalError, "[undefined behavior] detected overflow: #{value}"
+            end
           end
           I32(v)
         end
       when :i64
         if v >= 0
-          I64(v & (I64::I64_MAX >> 1))
+          i64_signed_max = I64::I64_MAX >> 1
+          if saturating
+            v = i64_signed_max if v > i64_signed_max
+          else
+            v = v & i64_signed_max
+          end
+          I64(v & i64_signed_max)
         else
-          v = v & I64::I64_MAX
-          if (v >> 31).zero?
-            raise EvalError, "[undefined behavior] detected overflow: #{value}"
+          i64_signed_min = -(I64::I64_MAX >> 1) - 1
+          if saturating
+            v = i64_signed_min if v < i64_signed_min
+          else
+            v = v & I64::I64_MAX
+            if (v >> 63).zero?
+              raise EvalError, "[undefined behavior] detected overflow: #{value}"
+            end
           end
           I64(v)
         end
@@ -570,18 +712,31 @@ module Wardite
 
     # @see the same as F32
     # @rbs to: Symbol
+    # @rbs saturating: bool
     # @rbs return: wasmValue
-    def trunc_u(to:)
+    def trunc_u(to:, saturating: false)
       v = value.to_i
       if v < 0
-        raise EvalError, "[undefined behavior] unexpected negative value"
+        if saturating
+          v = 0
+        else
+          raise EvalError, "[undefined behavior] unexpected negative value"
+        end
       end
       case to
       when :i32
-        v = v & I32::I32_MAX
+        if saturating
+          v = I32::I32_MAX if v > I32::I32_MAX
+        else
+          v = v & I32::I32_MAX
+        end
         I32(v)
       when :i64
-        v = v & I64::I64_MAX
+        if saturating
+          v = I64::I64_MAX if v > I64::I64_MAX
+        else
+          v = v & I64::I64_MAX
+        end
         I64(v)
       else
         raise EvalError, "unsupported operation to: #{to}"
@@ -623,6 +778,25 @@ module Wardite
       I64(v)
     end
 
+    # @rbs from: Symbol
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def extendN_s(from:, to:)
+      raise EvalError, "unsupported operation"
+    end
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_u(to:)
+      trunc_u(to: to, saturating: true)
+    end
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_s(to:)
+      trunc_s(to: to, saturating: true)
+    end
+
     def inspect
       "F64(#{@value})"
     end

data/lib/wardite/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Wardite
-  VERSION = "0.3.0" #: String
+  VERSION = "0.4.1" #: String
 end

data/lib/wardite.rb

@@ -57,6 +57,22 @@ module Wardite
           @types << Type.new(calltype, rettype)
         end
       end
+
+      check_data_count
+    end
+
+    # @rbs return: void
+    def check_data_count
+      data_count = self.data_count_section&.count
+      if data_count
+        actual_count = self.data_section&.segments&.size
+        if !actual_count
+          raise LoadError, "invalid data segment count"
+        end
+        if (data_count != actual_count)
+          raise LoadError, "invalid data segment count"
+        end
+      end
     end
 
     # @rbs return: ImportSection
@@ -129,6 +145,18 @@ module Wardite
       sec
     end
 
+    # @rbs return: DataCountSection|nil
+    def data_count_section
+      sec = @sections.find{|s| s.code == Const::SectionDataCount }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(DataCountSection)
+        raise(GenericError, "[BUG] found invalid data section")
+      end
+      sec
+    end
+
     # @rbs return: FunctionSection|nil
     def function_section
       sec = @sections.find{|s| s.code == Const::SectionFunction }
@@ -216,7 +244,7 @@ module Wardite
         call_by_index(start_section.func_index)
       end
     end
-    
+
     # @rbs name: String|Symbol
     # @rbs return: bool
     def callable?(name)
@@ -634,6 +662,57 @@ module Wardite
         memory = instance.store.memories[0] || raise("[BUG] no memory")
         stack.push(I32(memory.grow(delta.value)))
 
+      when :memory_init
+        idx = insn.operand[0]
+        if !idx.is_a?(Integer)
+          raise EvalError, "[BUG] invalid type of operand"
+        end
+        if insn.operand[1] != 0x0
+          $stderr.puts "warning: :memory_init is not ending with 0x00"
+        end
+        data_sec = instance.data_section
+        if !data_sec
+          raise EvalError, "data segment out of range"
+        end
+        data_seg = data_sec.segments[idx]
+        if !data_seg
+          raise EvalError, "data segment out of range"
+        end
+
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        length, src_offset, dest_offset = stack.pop, stack.pop, stack.pop
+        if !length.is_a?(I32) || !src_offset.is_a?(I32) || !dest_offset.is_a?(I32)
+          raise EvalError, "invalid stack values"
+        end
+        source = data_seg.data[src_offset.value...(src_offset.value+length.value)]
+        raise EvalError, "invalid source range" if !source
+        memory.data[dest_offset.value...(dest_offset.value+length.value)] = source
+
+      when :memory_copy
+        if insn.operand[0] != 0x0 || insn.operand[1] != 0x0
+          $stderr.puts "warning: :memory_copy is not ending with 0x00"
+        end
+        length, src_offset, dest_offset = stack.pop, stack.pop, stack.pop
+        if !length.is_a?(I32) || !src_offset.is_a?(I32) || !dest_offset.is_a?(I32)
+          raise EvalError, "invalid stack values"
+        end
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        source = memory.data[src_offset.value...(src_offset.value+length.value)]
+        raise EvalError, "invalid source range" if !source
+        memory.data[dest_offset.value...(dest_offset.value+length.value)] = source
+
+      when :memory_fill
+        if insn.operand[0] != 0x0
+          $stderr.puts "warning: :memory_fill is not ending with 0x00"
+        end
+        length, byte, dest_offset = stack.pop, stack.pop, stack.pop
+        if !length.is_a?(I32) || !byte.is_a?(I32) || !dest_offset.is_a?(I32)
+          raise EvalError, "invalid stack values"
+        end
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        source = byte.value.chr * length.value
+        memory.data[dest_offset.value...(dest_offset.value+length.value)] = source
+
       else
         raise "TODO! unsupported #{insn.inspect}"
       end
@@ -905,9 +984,12 @@ module Wardite
         data_section = inst.data_section
         if data_section
           data_section.segments.each do |segment|
-            memory = self.memories[segment.flags]
+            if segment.mode != :active
+              next
+            end
+            memory = self.memories[segment.mem_index]
             if !memory
-              raise GenericError, "invalid memory index: #{segment.flags}"
+              raise GenericError, "invalid memory index: #{segment.mem_index}"
             end
 
             data_start = segment.offset

data/scripts/gen_conv.rb

@@ -39,11 +39,18 @@ module GenConv
     code = DEF.dup
     method = op.to_s
     symbol = "#{to.to_s}_#{method}_#{from.to_sym}"
+    extra_kargs = ""
     
     if method == "extend"
       method = "extend_"
+    elsif method =~ /^extendN_(u|s)$/
+      suffix = $1
+      from_size = from.to_s.scan(/\d+/).join
+      symbol = "#{to.to_s}_extend_#{from_size}_#{suffix}"
+      extra_kargs = ", from: :#{from.to_s}"
     elsif method.end_with?("_s") or method.end_with?("_u")
-      core, suffix = *(method.split("_")[0..1])
+      core = method.sub(/_(s|u)$/, "")
+      suffix = method.scan(/_(s|u)$/).join
       symbol = "#{to.to_s}_#{core}_#{from.to_sym}_#{suffix}"
     end
     # NOTE to is as namespace
@@ -52,11 +59,14 @@ module GenConv
     code.gsub!(/\$\{TO\}/, to.to_s)
     code.gsub!(/\$\{TO_CLASS\}/, to_class(to.to_sym))
     code.gsub!(/\$\{FROM_CLASS\}/, to_class(from.to_sym))
+    code.gsub!(/\$\{EXTRA_KARGS\}/, extra_kargs)
     return code
   end
 
   def self.to_class(typ)
     {
+      i8: "I32",
+      i16: "I32",
       i32: "I32",
       i64: "I64",
       f32: "F32",
@@ -69,7 +79,7 @@ module GenConv
     when :${SYMBOL}
       from = runtime.stack.pop
       raise EvalError, "maybe empty or invalid stack" if !from.is_a?(${FROM_CLASS})
-      to = from.${METHOD}(to: :${TO})
+      to = from.${METHOD}(to: :${TO}${EXTRA_KARGS})
       raise EvalError, "failed to convert type" if !to.is_a?(${TO_CLASS})
       runtime.stack.push(to)
   RUBY

data/sig/generated/wardite/const.rbs

@@ -28,6 +28,8 @@ module Wardite
     SectionCode: Integer
 
     SectionData: Integer
+
+    SectionDataCount: Integer
   end
 
   include Const

data/sig/generated/wardite/instruction.rbs

@@ -7,9 +7,14 @@ module Wardite
     # @see https://pengowray.github.io/wasm-ops/
     SYMS: Array[Symbol]
 
+    FC_SYMS: Array[Symbol]
+
     # @rbs return: Hash[Integer, Symbol]
     def self.table: () -> Hash[Integer, Symbol]
 
+    # @rbs return: Hash[Integer, Symbol]
+    def self.fc_table: () -> Hash[Integer, Symbol]
+
     attr_accessor namespace: Symbol
 
     attr_accessor code: Symbol
@@ -26,6 +31,10 @@ module Wardite
     # @rbs return: [Symbol, Symbol]
     def self.to_sym: (String chr) -> [ Symbol, Symbol ]
 
+    # @rbs lower: Integer
+    # @rbs return: [Symbol, Symbol]
+    def self.resolve_fc_sym: (Integer lower) -> [ Symbol, Symbol ]
+
     # @rbs code: Symbol
     # @rbs return: Array[Symbol]
     def self.operand_of: (Symbol code) -> Array[Symbol]

data/sig/generated/wardite/leb128.rbs

@@ -4,11 +4,12 @@
 module Wardite
   module Leb128Helper
     # @rbs buf: File|StringIO
+    # @rbs max_level: Integer
     # @rbs return: Integer
-    def fetch_uleb128: (File | StringIO buf) -> Integer
+    def fetch_uleb128: (File | StringIO buf, ?max_level: Integer) -> Integer
 
     # @rbs buf: File|StringIO
     # @rbs return: Integer
-    def fetch_sleb128: (File | StringIO buf) -> Integer
+    def fetch_sleb128: (File | StringIO buf, ?max_level: untyped) -> Integer
   end
 end

data/sig/generated/wardite/load.rbs

@@ -103,7 +103,9 @@ module Wardite
 
   class DataSection < Section
     class Segment
-      attr_accessor flags: Integer
+      attr_accessor mode: :active | :passive
+
+      attr_accessor mem_index: Integer
 
       attr_accessor offset: Integer
 
@@ -120,6 +122,14 @@ module Wardite
     def initialize: () -> void
   end
 
+  class DataCountSection < Section
+    attr_accessor count: Integer
+
+    # @rbs count: Integer
+    # @rbs return: void
+    def initialize: (Integer count) -> void
+  end
+
   class ExportSection < Section
     class ExportDesc
       attr_accessor name: String
@@ -206,9 +216,17 @@ module Wardite
     # @rbs return: Array[::Wardite::Op]
     def self.code_body: (StringIO buf) -> Array[::Wardite::Op]
 
+    # @rbs c: String
+    # @rbs buf: StringIO
+    # @rbs return: [Symbol, Symbol]
+    def self.resolve_code: (String c, StringIO buf) -> [ Symbol, Symbol ]
+
     # @rbs return: DataSection
     def self.data_section: () -> DataSection
 
+    # @rbs return: DataCountSection
+    def self.data_count_section: () -> DataCountSection
+
     # @rbs sbuf: StringIO
     # @rbs return: String
     def self.fetch_insn_while_end: (StringIO sbuf) -> String

data/sig/generated/wardite/value.rbs

@@ -36,7 +36,7 @@ module Wardite
   class I32
     include ValueHelper
 
-    I32_MAX: untyped
+    I32_MAX: Integer
 
     # value should be stored as unsigned Integer, even in I32/I64
     # when we want to access signed value, it'd be done via #value_s
@@ -100,6 +100,19 @@ module Wardite
     # @rbs return: wasmValue
     def reinterpret: (to: Symbol) -> wasmValue
 
+    # @rbs from: Symbol
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def extendN_s: (from: Symbol, to: Symbol) -> wasmValue
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_u: (to: Symbol) -> wasmValue
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_s: (to: Symbol) -> wasmValue
+
     # I32#inspect shows signed value for convinience
     def inspect: () -> untyped
   end
@@ -107,7 +120,7 @@ module Wardite
   class I64
     include ValueHelper
 
-    I64_MAX: untyped
+    I64_MAX: Integer
 
     attr_accessor value: Integer
 
@@ -168,6 +181,19 @@ module Wardite
     # @rbs return: wasmValue
     def reinterpret: (to: Symbol) -> wasmValue
 
+    # @rbs from: Symbol
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def extendN_s: (from: Symbol, to: Symbol) -> wasmValue
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_u: (to: Symbol) -> wasmValue
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_s: (to: Symbol) -> wasmValue
+
     # I64#inspect shows signed value
     def inspect: () -> untyped
   end
@@ -205,14 +231,18 @@ module Wardite
 
     # @todo need more testcase...
     # @see https://webassembly.github.io/spec/core/exec/numerics.html#xref-exec-numerics-op-trunc-s-mathrm-trunc-mathsf-s-m-n-z
+    # @see copy this impl to F64 when changed
     # @rbs to: Symbol
+    # @rbs saturating: bool
     # @rbs return: wasmValue
-    def trunc_s: (to: Symbol) -> wasmValue
+    def trunc_s: (to: Symbol, ?saturating: bool) -> wasmValue
 
     # @see https://webassembly.github.io/spec/core/exec/numerics.html#xref-exec-numerics-op-trunc-u-mathrm-trunc-mathsf-u-m-n-z
+    # @see copy this impl to F64 when changed
     # @rbs to: Symbol
+    # @rbs sturating: bool
     # @rbs return: wasmValue
-    def trunc_u: (to: Symbol) -> wasmValue
+    def trunc_u: (to: Symbol, ?saturating: untyped) -> wasmValue
 
     # @rbs to: Symbol
     # @rbs return: wasmValue
@@ -234,6 +264,19 @@ module Wardite
     # @rbs return: wasmValue
     def reinterpret: (to: Symbol) -> wasmValue
 
+    # @rbs from: Symbol
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def extendN_s: (from: Symbol, to: Symbol) -> wasmValue
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_u: (to: Symbol) -> wasmValue
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_s: (to: Symbol) -> wasmValue
+
     def inspect: () -> untyped
   end
 
@@ -270,13 +313,15 @@ module Wardite
 
     # @see the same as F32
     # @rbs to: Symbol
+    # @rbs saturating: bool
     # @rbs return: wasmValue
-    def trunc_s: (to: Symbol) -> wasmValue
+    def trunc_s: (to: Symbol, ?saturating: bool) -> wasmValue
 
     # @see the same as F32
     # @rbs to: Symbol
+    # @rbs saturating: bool
     # @rbs return: wasmValue
-    def trunc_u: (to: Symbol) -> wasmValue
+    def trunc_u: (to: Symbol, ?saturating: bool) -> wasmValue
 
     # @rbs to: Symbol
     # @rbs return: wasmValue
@@ -299,6 +344,19 @@ module Wardite
     # @rbs return: wasmValue
     def reinterpret: (to: Symbol) -> wasmValue
 
+    # @rbs from: Symbol
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def extendN_s: (from: Symbol, to: Symbol) -> wasmValue
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_u: (to: Symbol) -> wasmValue
+
+    # @rbs to: Symbol
+    # @rbs return: wasmValue
+    def trunc_sat_s: (to: Symbol) -> wasmValue
+
     def inspect: () -> untyped
   end
 end

data/sig/generated/wardite.rbs

@@ -26,6 +26,9 @@ module Wardite
     # @rbs &blk: (Instance) -> void
     def initialize: (Hash[Symbol, Hash[Symbol, wasmCallable]] import_object) { (Instance) -> void } -> untyped
 
+    # @rbs return: void
+    def check_data_count: () -> void
+
     # @rbs return: ImportSection
     def import_section: () -> ImportSection
 
@@ -44,6 +47,9 @@ module Wardite
     # @rbs return: DataSection|nil
     def data_section: () -> (DataSection | nil)
 
+    # @rbs return: DataCountSection|nil
+    def data_count_section: () -> (DataCountSection | nil)
+
     # @rbs return: FunctionSection|nil
     def function_section: () -> (FunctionSection | nil)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wardite
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Uchio Kondo
@@ -37,6 +37,9 @@ files:
 - examples/local_set.wat
 - examples/loop.wat
 - examples/memory.wat
+- examples/memory_init.wat
+- examples/saturate.wat
+- examples/saturate_u.wat
 - examples/start.wat
 - exe/wardite
 - lib/wardite.rb