wardite 0.2.2 → 0.4.0

data/lib/wardite/load.rb

@@ -35,8 +35,23 @@ module Wardite
     end
   end
 
+  class TableSection < Section
+    attr_accessor :table_types #: Array[Symbol]
+
+    attr_accessor :table_limits #: Array[[Integer, Integer?]]
+
+    # @rbs return: void
+    def initialize
+      self.name = "Table"
+      self.code = 0x4
+
+      @table_types = []
+      @table_limits = []
+    end
+  end
+
   class MemorySection < Section
-    attr_accessor :limits #: Array[[Integer, Integer|nil]]
+    attr_accessor :limits #: Array[[Integer, Integer?]]
 
     # @rbs return: void
     def initialize
@@ -56,7 +71,7 @@ module Wardite
       # TODO: unused in wasm 1.0 spec?
       attr_accessor :shared #: bool
 
-      attr_accessor :value #: I32|I64|F32|F64
+      attr_accessor :value #: wasmValue
 
       # @rbs &blk: (Global) -> void
       # @rbs return: void
@@ -76,6 +91,35 @@ module Wardite
     end
   end
 
+  class StartSection < Section
+    attr_accessor :func_index #: Integer
+
+    # @rbs return: void
+    def initialize
+      self.name = "Start"
+      self.code = 0x8
+      self.func_index = -1
+    end
+  end
+
+  class ElemSection < Section
+    attr_accessor :table_indices #: Array[Integer]
+
+    attr_accessor :table_offsets #: Array[Integer]
+
+    attr_accessor :element_indices #: Array[Array[Integer]]
+
+    # @rbs return: void
+    def initialize
+      self.name = "Elem"
+      self.code = 0x9
+
+      @table_indices = []
+      @table_offsets = []
+      @element_indices = []
+    end
+  end
+
   class CodeSection < Section
     class CodeBody
       attr_accessor :locals_count #: Array[Integer]
@@ -104,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
 
@@ -128,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
@@ -186,8 +245,10 @@ module Wardite
     extend Wardite::Leb128Helper
     extend Wardite::ValueHelper
 
+    # @rbs self.@buf: File|StringIO
+
     # @rbs buf: File|StringIO
-    # @rbs import_object: Hash[Symbol, Hash[Symbol, Proc]]
+    # @rbs import_object: Hash[Symbol, Hash[Symbol, wasmCallable]]
     # @rbs enable_wasi: boolish
     # @rbs return: Instance
     def self.load_from_buffer(buf, import_object: {}, enable_wasi: true)
@@ -249,7 +310,7 @@ module Wardite
           when Wardite::SectionFunction
             function_section
           when Wardite::SectionTable
-            unimplemented_skip_section(code)
+            table_section
           when Wardite::SectionMemory
             memory_section
           when Wardite::SectionGlobal
@@ -257,13 +318,15 @@ module Wardite
           when Wardite::SectionExport
             export_section
           when Wardite::SectionStart
-            unimplemented_skip_section(code)
+            start_section
           when Wardite::SectionElement
-            unimplemented_skip_section(code)
+            elem_section
           when Wardite::SectionCode
             code_section
           when Wardite::SectionData
             data_section
+          when Wardite::Const::SectionDataCount
+            data_count_section
           when Wardite::SectionCustom
             unimplemented_skip_section(code)
           else
@@ -387,6 +450,50 @@ module Wardite
       dest
     end
 
+    # @rbs return: StartSection
+    def self.start_section
+      dest = StartSection.new
+      size = fetch_uleb128(@buf)
+      dest.size = size
+      # StartSection won't use size
+      func_index = fetch_uleb128(@buf)
+      dest.func_index = func_index
+      dest
+    end
+
+    # @rbs return: ElemSection
+    def self.elem_section
+      dest = ElemSection.new
+      size = fetch_uleb128(@buf)
+      dest.size = size
+      sbuf = StringIO.new(@buf.read(size) || raise("buffer too short"))
+
+      len = fetch_uleb128(sbuf)
+      len.times do |i|
+        etype = fetch_uleb128(sbuf)
+        case etype
+        when 0x0 # expr, vec(funcidx)
+          dest.table_indices << 0 # default and fixed to table[0]
+
+          code = fetch_insn_while_end(sbuf)
+          ops = code_body(StringIO.new(code))
+          offset = decode_expr(ops)
+          dest.table_offsets << offset
+
+          elms = []
+          elen = fetch_uleb128(sbuf)
+          elen.times do |i|
+            index = fetch_uleb128(sbuf)
+            elms << index
+          end
+          dest.element_indices << elms
+        else
+          raise NotImplementedError, "element section type #{etype} is a TODO!"
+        end
+      end
+      dest
+    end
+
     # @rbs return: GlobalSection
     def self.global_section
       dest = GlobalSection.new
@@ -433,6 +540,30 @@ module Wardite
       dest
     end
 
+    # @rbs return: TableSection
+    def self.table_section
+      dest = TableSection.new
+      size = fetch_uleb128(@buf)
+      dest.size = size
+      sbuf = StringIO.new(@buf.read(size) || raise("buffer too short"))
+
+      len = fetch_uleb128(sbuf)
+      len.times do |i|
+        code = fetch_uleb128(sbuf)
+        type = Op.i2type(code)
+        dest.table_types << type
+
+        flags = fetch_uleb128(sbuf)
+        min = fetch_uleb128(sbuf)
+        max = nil
+        if flags != 0
+          max = fetch_uleb128(sbuf)
+        end
+        dest.table_limits << [min, max]
+      end
+      dest
+    end
+
     # @rbs return: CodeSection
     def self.code_section
       dest = CodeSection.new
@@ -476,9 +607,9 @@ 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[Integer|Float|Block]
+        operand = [] #: Array[operandItem]
         operand_types.each do |typ|
           case typ
           when :u8
@@ -489,6 +620,13 @@ module Wardite
             operand << ope.ord
           when :u32
             operand << fetch_uleb128(buf)
+          when :u32_vec
+            len = fetch_uleb128(buf)
+            vec = [] #: Array[Integer]
+            len.times do
+              vec << fetch_uleb128(buf)
+            end
+            operand << vec
           when :i32
             operand << fetch_sleb128(buf)
           when :i64
@@ -509,7 +647,7 @@ module Wardite
             v = data.unpack("E")[0]
             raise "String#unpack is broken" if !v.is_a?(Float)
             operand << v
-          when :u8_if_block # :if specific
+          when :u8_block
             block_ope = buf.read 1
             if ! block_ope
               raise LoadError, "buffer too short for if"
@@ -531,6 +669,18 @@ module Wardite
       dest
     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
     def self.data_section
       dest = DataSection.new
@@ -540,27 +690,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)
@@ -599,7 +776,7 @@ module Wardite
     end
 
     # @rbs ops: Array[Op]
-    # @rbs return: I32|I64|F32|F64
+    # @rbs return: wasmValue
     def self.decode_global_expr(ops)
       # sees first opcode
       op = ops.first
@@ -619,7 +796,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