wardite 0.2.1 → 0.2.2

data/lib/wardite.rb

@@ -6,6 +6,7 @@ require_relative "wardite/leb128"
 require_relative "wardite/const"
 require_relative "wardite/instruction"
 require_relative "wardite/value"
+require_relative "wardite/load"
 
 module Wardite
   module Evaluator
@@ -23,596 +24,6 @@ require_relative "wardite/wasi"
 require "stringio"
 
 module Wardite
-  class Section
-    attr_accessor :name #: String
-  
-    attr_accessor :code #: Integer
-
-    attr_accessor :size #: Integer
-  end
-
-  class TypeSection < Section
-    attr_accessor :defined_types #: Array[Array[Symbol]]
-
-    attr_accessor :defined_results #: Array[Array[Symbol]]
-
-    # @rbs return: void
-    def initialize
-      self.name = "Type"
-      self.code = 0x1
-
-      @defined_types = []
-      @defined_results = []
-    end
-  end
-
-  class FunctionSection < Section
-    attr_accessor :func_indices #: Array[Integer]
-
-    # @rbs return: void
-    def initialize
-      self.name = "Function"
-      self.code = 0x3
-
-      @func_indices = []
-    end
-  end
-
-  class MemorySection < Section
-    attr_accessor :limits #: Array[[Integer, Integer|nil]]
-
-    # @rbs return: void
-    def initialize
-      self.name = "Memory"
-      self.code = 0x5
-
-      @limits = []
-    end
-  end
-
-  class CodeSection < Section
-    class CodeBody
-      attr_accessor :locals_count #: Array[Integer]
-
-      attr_accessor :locals_type #: Array[Symbol]
-
-      attr_accessor :body #: Array[Op]
-
-      # @rbs &blk: (CodeBody) -> void
-      # @rbs return: void
-      def initialize(&blk)
-        blk.call(self)
-      end
-    end
-
-    attr_accessor :func_codes #:Array[CodeBody]
-
-    # @rbs return: void
-    def initialize
-      self.name = "Code"
-      self.code = 0xa
-
-      @func_codes = []
-    end
-  end
-
-  class DataSection < Section
-    class Segment
-      attr_accessor :flags #: Integer
-      
-      attr_accessor :offset #: Integer
-
-      attr_accessor :data #: String
-
-      # @rbs &blk: (Segment) -> void
-      # @rbs return: void
-      def initialize(&blk)
-        blk.call(self)
-      end
-    end
-
-    attr_accessor :segments #: Array[Segment]
-
-    # @rbs return: void
-    def initialize
-      self.name = "Data"
-      self.code = 0xb
-
-      @segments = []
-    end
-  end
-
-  class ExportSection < Section
-    class ExportDesc
-      attr_accessor :name #: String
-      
-      attr_accessor :kind #: Integer
-
-      attr_accessor :func_index #: Integer
-    end
-
-    attr_accessor :exports #: Hash[String, ExportDesc]
-
-    def initialize #: void
-      self.name = "Export"
-      self.code = 0x7
-
-      @exports = {}
-    end
-
-    # @rbs &blk: (ExportDesc) -> void
-    def add_desc(&blk)
-      desc = ExportDesc.new
-      blk.call(desc)
-      self.exports[desc.name] = desc
-    end
-  end
-
-  class ImportSection < Section
-    class ImportDesc
-      attr_accessor :module_name #: String
-
-      attr_accessor :name #: String
-      
-      attr_accessor :kind #: Integer
-
-      attr_accessor :sig_index #: Integer
-    end
-
-    attr_accessor :imports #: Array[ImportDesc]
-
-    def initialize #: void
-      self.name = "Import"
-      self.code = 0x2
-
-      @imports = []
-    end
-
-    # @rbs &blk: (ImportDesc) -> void
-    def add_desc(&blk)
-      desc = ImportDesc.new
-      blk.call(desc) if blk
-      self.imports << desc
-    end
-  end
-
-  module BinaryLoader
-    extend Wardite::Leb128Helper
-    extend Wardite::ValueHelper
-
-    # @rbs buf: File|StringIO
-    # @rbs import_object: Hash[Symbol, Hash[Symbol, Proc]]
-    # @rbs enable_wasi: boolish
-    # @rbs return: Instance
-    def self.load_from_buffer(buf, import_object: {}, enable_wasi: true)
-      @buf = buf
-
-      version = preamble
-      sections_ = sections
-
-      if enable_wasi
-        wasi_env = Wardite::WasiSnapshotPreview1.new       
-        import_object[:wasi_snapshot_preview1] = wasi_env.to_module
-      end
-
-      return Instance.new(import_object) do |i|
-        i.version = version
-        i.sections = sections_
-      end
-    end
-
-    # @rbs return: Integer
-    def self.preamble
-      asm = @buf.read 4
-      if !asm
-        raise LoadError, "buffer too short"
-      end
-      if asm != "\u0000asm"
-        raise LoadError, "invalid preamble"
-      end
-
-      vstr = @buf.read(4)
-      if !vstr
-        raise LoadError, "buffer too short"
-      end
-      version = vstr.to_enum(:chars)
-        .with_index
-        .inject(0) {|dest, (c, i)| dest | (c.ord << i*8) }
-      if version != 1
-        raise LoadError, "unsupported version: #{version}"
-      end
-      version
-    end
-
-    # @rbs return: Array[Section]
-    def self.sections
-      sections = [] #: Array[Section]
-
-      loop do
-        byte = @buf.read(1)
-        if !byte
-          break
-        end
-        code = byte.ord
-
-        section = case code
-          when Wardite::SectionType
-            type_section
-          when Wardite::SectionImport
-            import_section
-          when Wardite::SectionFunction
-            function_section
-          when Wardite::SectionTable
-            unimplemented_skip_section(code)
-          when Wardite::SectionMemory
-            memory_section
-          when Wardite::SectionGlobal
-            unimplemented_skip_section(code)
-          when Wardite::SectionExport
-            export_section
-          when Wardite::SectionStart
-            unimplemented_skip_section(code)
-          when Wardite::SectionElement
-            unimplemented_skip_section(code)
-          when Wardite::SectionCode
-            code_section
-          when Wardite::SectionData
-            data_section
-          when Wardite::SectionCustom
-            unimplemented_skip_section(code)
-          else
-            raise LoadError, "unknown code: #{code}(\"#{code.to_s 16}\")"
-          end
-
-        if section
-          sections << section
-        end
-      end
-      sections
-    end
-
-    # @rbs return: TypeSection
-    def self.type_section
-      dest = TypeSection.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|
-        fncode = assert_read(sbuf, 1)
-        if fncode != "\x60"
-          raise LoadError, "not a function definition"
-        end
-
-        arglen = fetch_uleb128(sbuf)
-        arg = []
-        arglen.times do
-          case ty = assert_read(sbuf, 1)&.ord
-          when 0x7f
-            arg << :i32
-          when 0x7e
-            arg << :i64
-          when 0x7d
-            arg << :f32
-          when 0x7c
-            arg << :f64
-          else
-            raise NotImplementedError, "unsupported for now: #{ty.inspect}"
-          end
-        end
-        dest.defined_types << arg
-
-        retlen = fetch_uleb128(sbuf)
-        ret = []
-        retlen.times do
-          case ty = assert_read(sbuf, 1)&.ord
-          when 0x7f
-            ret << :i32
-          when 0x7e
-            ret << :i64
-          when 0x7d
-            ret << :f32
-          when 0x7c
-            ret << :f64
-          else
-            raise NotImplementedError, "unsupported for now: #{ty.inspect}"
-          end
-        end
-        dest.defined_results << ret
-      end
-
-      dest
-    end
-
-    # @rbs return: ImportSection
-    def self.import_section
-      dest = ImportSection.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|
-        mlen = fetch_uleb128(sbuf)
-        module_name = assert_read(sbuf, mlen)
-        nlen = fetch_uleb128(sbuf)
-        name = assert_read(sbuf, nlen)
-        kind_ = assert_read(sbuf, 1)
-        kind = kind_[0]&.ord
-        if !kind
-          raise "[BUG] empty unpacked string" # guard rbs
-        end
-
-        index = fetch_uleb128(sbuf)
-        dest.add_desc do |desc|
-          desc.module_name = module_name
-          desc.name = name
-          desc.kind = kind
-          desc.sig_index = index
-        end
-      end
-
-      dest
-    end
-
-    # @rbs return: MemorySection
-    def self.memory_section
-      dest = MemorySection.new
-      size = fetch_uleb128(@buf)
-      dest.size = size
-      sbuf = StringIO.new(@buf.read(size) || raise("buffer too short"))
-
-      len = fetch_uleb128(sbuf)
-      if len != 1
-        raise LoadError, "memory section has invalid size: #{len}"
-      end
-      len.times do |i|
-        flags = fetch_uleb128(sbuf)
-        min = fetch_uleb128(sbuf)
-
-        max = nil
-        if flags != 0
-          max = fetch_uleb128(sbuf)
-        end
-        dest.limits << [min, max]
-      end
-      dest
-    end
-    
-    # @rbs return: FunctionSection
-    def self.function_section
-      dest = FunctionSection.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|
-        index = fetch_uleb128(sbuf)
-        dest.func_indices << index
-      end
-      dest
-    end
-
-    # @rbs return: CodeSection
-    def self.code_section
-      dest = CodeSection.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|
-        ilen = fetch_uleb128(sbuf)
-        code = assert_read(sbuf, ilen)
-        last_code = code[-1]
-        if ! last_code
-          raise "[BUG] empty code fetched" # guard for steep check
-        end
-        if last_code.ord != 0x0b
-          $stderr.puts "warning: instruction not ended with inst end(0x0b): 0x0#{last_code.ord}" 
-        end
-        cbuf = StringIO.new(code)
-        locals_count = []
-        locals_type = []
-        locals_len = fetch_uleb128(cbuf)
-        locals_len.times do
-          type_count = fetch_uleb128(cbuf)
-          locals_count << type_count
-          value_type = assert_read(cbuf, 1)&.ord
-          locals_type << Op.i2type(value_type || -1)
-        end
-        body = code_body(cbuf)
-        dest.func_codes << CodeSection::CodeBody.new do |b|
-          b.locals_count = locals_count
-          b.locals_type = locals_type
-          b.body = body
-        end
-      end
-      dest
-    end
-
-    # @rbs buf: StringIO
-    # @rbs return: Array[::Wardite::Op]
-    def self.code_body(buf)
-      dest = []
-      while c = buf.read(1)
-        namespace, code = Op.to_sym(c)
-        operand_types = Op.operand_of(code)
-        operand = [] #: Array[Integer|Float|Block]
-        operand_types.each do |typ|
-          case typ
-          when :u8
-            ope = buf.read 1
-            if ! ope
-              raise LoadError, "buffer too short"
-            end
-            operand << ope.ord
-          when :u32
-            operand << fetch_uleb128(buf)
-          when :i32
-            operand << fetch_sleb128(buf)
-          when :i64
-            operand << fetch_sleb128(buf)
-          when :f32
-            data = buf.read 4
-            if !data || data.size != 4
-              raise LoadError, "buffer too short"
-            end
-            v = data.unpack("e")[0]
-            raise "String#unpack is broken" if !v.is_a?(Float)
-            operand << v
-          when :f64
-            data = buf.read 8
-            if !data || data.size != 8
-              raise LoadError, "buffer too short"
-            end
-            v = data.unpack("E")[0]
-            raise "String#unpack is broken" if !v.is_a?(Float)
-            operand << v
-          when :u8_if_block # :if specific
-            block_ope = buf.read 1
-            if ! block_ope
-              raise LoadError, "buffer too short for if"
-            end
-            if block_ope.ord == 0x40
-              operand << Block.void
-            else
-              operand << Block.new([block_ope.ord])
-            end
-          else
-            $stderr.puts "warning: unknown type #{typ.inspect}. defaulting to u32"
-            operand << fetch_uleb128(buf)
-          end         
-        end
-
-        dest << Op.new(namespace, code, operand)
-      end
-
-      dest
-    end
-
-    # @rbs return: DataSection
-    def self.data_section
-      dest = DataSection.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|
-        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
-        end
-        dest.segments << segment
-      end
-      dest
-    end
-
-    # @rbs sbuf: StringIO
-    # @rbs return: String
-    def self.fetch_insn_while_end(sbuf)
-      code = String.new("")
-      loop {
-        c = sbuf.read 1
-        if !c
-          break
-        end
-        code << c
-        if c == "\u000b" # :end
-          break
-        end
-      }
-      code
-    end
-
-    # @rbs ops: Array[Op]
-    # @rbs return: Integer
-    def self.decode_expr(ops)
-      # sees first opcode
-      op = ops.first
-      if !op
-        raise LoadError, "empty opcodes"
-      end
-      case op.code
-      when :i32_const
-        arg = op.operand[0]
-        if !arg.is_a?(Integer)
-          raise "Invalid definition of operand"
-        end
-        return arg
-      else
-        raise "Unimplemented offset op: #{op.code.inspect}"
-      end
-    end
-
-    # @rbs return: ExportSection
-    def self.export_section
-      dest = ExportSection.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|
-        nlen = fetch_uleb128(sbuf)
-        name = assert_read(sbuf, nlen)
-        kind_ = assert_read(sbuf, 1)
-        kind = kind_[0]&.ord
-        if !kind
-          raise "[BUG] empty unpacked string" # guard rbs
-        end
-
-        index = fetch_uleb128(sbuf)
-        dest.add_desc do |desc|
-          desc.name = name
-          desc.kind = kind
-          desc.func_index = index
-        end
-      end
-
-      dest
-    end
-
-    # @rbs code: Integer
-    # @rbs return: nil
-    def self.unimplemented_skip_section(code)
-      $stderr.puts "warning: unimplemented section: 0x0#{code}"
-      size = @buf.read(1)&.ord
-      @buf.read(size)
-      nil
-    end
-
-    # @rbs sbuf: StringIO
-    # @rbs n: Integer
-    # @rbs return: String
-    def self.assert_read(sbuf, n)
-      ret = sbuf.read n
-      if !ret
-        raise LoadError, "too short section size"
-      end
-      if ret.size != n
-        raise LoadError, "too short section size"
-      end
-      ret
-    end
-  end
-
   class Instance
     attr_accessor :version #: Integer
 
@@ -671,6 +82,18 @@ module Wardite
       sec
     end
 
+    # @rbs return: GlobalSection|nil
+    def global_section
+      sec = @sections.find{|s| s.code == Const::SectionGlobal }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(GlobalSection)
+        raise(GenericError, "instance doesn't have required section")
+      end
+      sec
+    end
+
     # @rbs return: DataSection|nil
     def data_section
       sec = @sections.find{|s| s.code == Const::SectionData }
@@ -985,6 +408,36 @@ module Wardite
         end
         frame.locals[idx] = value
 
+      when :global_get
+        idx = insn.operand[0]
+        if !idx.is_a?(Integer)
+          raise EvalError, "[BUG] invalid type of operand"
+        end
+        global = instance.store.globals[idx]
+        if !global
+          raise EvalError, "global not found"
+        end
+        stack.push(global.value)
+
+      when :global_set
+        idx = insn.operand[0]
+        if !idx.is_a?(Integer)
+          raise EvalError, "[BUG] invalid type of operand"
+        end
+        current_global = instance.store.globals[idx]
+        if !current_global
+          raise EvalError, "global index not valid"
+        end
+        if !current_global.mutable?
+          raise EvalError, "global not mutable"
+        end
+        value = stack.pop
+        if !value
+          raise EvalError, "value should be pushed"
+        end
+        current_global.value = value
+        instance.store.globals[idx] = current_global
+
       when :memory_size
         memory = instance.store.memories[0] || raise("[BUG] no memory")
         stack.push(I32(memory.current))
@@ -1137,9 +590,11 @@ module Wardite
     attr_accessor :funcs #: Array[WasmFunction|ExternalFunction]
 
     # FIXME: attr_accessor :modules
-     
+
     attr_accessor :memories #: Array[Memory]
 
+    attr_accessor :globals #: Array[Global]
+
     # @rbs inst: Instance
     # @rbs return: void
     def initialize(inst)
@@ -1201,6 +656,19 @@ module Wardite
           end
         end
       end
+
+      @globals = []
+      global_section = inst.global_section
+      if global_section
+        global_section.globals.each do |g|
+          @globals << Global.new do |g2|
+            g2.type = g.type
+            g2.mutable = g.mutable
+            g2.shared = g.shared
+            g2.value = g.value
+          end
+        end
+      end
     end
 
     # @rbs idx: Integer
@@ -1243,6 +711,26 @@ module Wardite
     end
   end
 
+  class Global
+    attr_accessor :type #: Symbol
+    
+    attr_accessor :mutable #: bool
+
+    # TODO: unused in wasm 1.0 spec?
+    attr_accessor :shared #: bool
+
+    attr_accessor :value #: I32|I64|F32|F64
+
+    # @rbs &blk: (Global) -> void
+    # @rbs return: void
+    def initialize(&blk)
+      blk.call(self)
+    end
+
+    alias mutable? mutable
+    alias shared? shared
+  end
+
   class WasmData
     attr_accessor :memory_index #: Integer
 

data/sig/generated/wardite/instruction.rbs

@@ -24,9 +24,9 @@ module Wardite
     # @rbs return: [Symbol, Symbol]
     def self.to_sym: (String chr) -> [ Symbol, Symbol ]
 
-    # @rbs chr: Symbol
+    # @rbs code: Symbol
     # @rbs return: Array[Symbol]
-    def self.operand_of: (untyped code) -> Array[Symbol]
+    def self.operand_of: (Symbol code) -> Array[Symbol]
 
     # @see https://www.w3.org/TR/wasm-core-1/#value-types%E2%91%A2
     # @rbs code: Integer