wardite 0.2.0 → 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
@@ -13,570 +14,16 @@ module Wardite
   end
 end
 require_relative "wardite/alu_i32.generated"
+require_relative "wardite/alu_i64.generated"
+require_relative "wardite/alu_f32.generated"
+require_relative "wardite/alu_f64.generated"
+require_relative "wardite/convert.generated"
 
 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
-          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
-          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 :u32
-            operand << fetch_uleb128(buf)
-          when :i32
-            operand << fetch_sleb128(buf)
-          when :u8_block # :if specific
-            block_ope = buf.read 1
-            if ! block_ope
-              raise "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
 
@@ -635,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 }
@@ -688,7 +147,7 @@ module Wardite
     include ValueHelper
 
     # TODO: add types of class that the stack accomodates
-    attr_accessor :stack #: Array[I32|I64|F32|F64|Block]
+    attr_accessor :stack #: Array[I32|I64|F32|F64]
 
     attr_accessor :call_stack #: Array[Frame]
 
@@ -848,12 +307,25 @@ module Wardite
     # @rbs return: void
     def eval_insn(frame, insn)
       case insn.namespace
+      when :convert
+        return Evaluator.convert_eval_insn(self, frame, insn)
       when :i32
         return Evaluator.i32_eval_insn(self, frame, insn)
+      when :i64
+        return Evaluator.i64_eval_insn(self, frame, insn)
+      when :f32
+        return Evaluator.f32_eval_insn(self, frame, insn)
+      when :f64
+        return Evaluator.f64_eval_insn(self, frame, insn)
       end
 
       # unmached namespace...
       case insn.code
+      when :unreachable
+        raise Unreachable, "unreachable op"
+      when :nop
+        return
+
       when :if
         block = insn.operand[0]
         raise EvalError, "if op without block" if !block.is_a?(Block)
@@ -866,78 +338,6 @@ module Wardite
 
         label = Label.new(:if, next_pc, stack.size, block.result_size)
         frame.labels.push(label)
-        
-      when :local_get
-        idx = insn.operand[0]
-        if !idx.is_a?(Integer)
-          raise EvalError, "[BUG] invalid type of operand"
-        end
-        local = frame.locals[idx]
-        if !local
-          raise EvalError, "local not found"
-        end
-        stack.push(local)
-      when :local_set
-        idx = insn.operand[0]
-        if !idx.is_a?(Integer)
-          raise EvalError, "[BUG] invalid type of operand"
-        end
-        value = stack.pop
-        if !value
-          raise EvalError, "value should be pushed"
-        end
-        if value.is_a?(Block)
-          raise EvalError, "block value detected"
-        end
-        frame.locals[idx] = value
-
-      # when :i32_lts
-      #   right, left = stack.pop, stack.pop
-      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
-      #     raise EvalError, "maybe empty stack"
-      #   end
-      #   value = (left < right) ? 1 : 0
-      #   stack.push(value)
-      # when :i32_leu
-      #   right, left = stack.pop, stack.pop
-      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
-      #     raise EvalError, "maybe empty stack"
-      #   end
-      #   value = (left >= right) ? 1 : 0
-      #   stack.push(value)
-      # when :i32_add
-      #   right, left = stack.pop, stack.pop
-      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
-      #     raise EvalError, "maybe empty stack"
-      #   end
-      #   stack.push(left + right)
-      # when :i32_sub
-      #   right, left = stack.pop, stack.pop
-      #   if !right.is_a?(Integer) || !left.is_a?(Integer)
-      #     raise EvalError, "maybe empty stack"
-      #   end
-      #   stack.push(left - right)
-      # when :i32_const
-      #   const = insn.operand[0]
-      #   if !const.is_a?(Integer)
-      #     raise EvalError, "[BUG] invalid type of operand"
-      #   end
-      #   stack.push(const)
-      # when :i32_store
-      #   _align = insn.operand[0] # TODO: alignment support?
-      #   offset = insn.operand[1]
-      #   raise EvalError, "[BUG] invalid type of operand" if !offset.is_a?(Integer)
-
-      #   value = stack.pop
-      #   addr = stack.pop
-      #   if !value.is_a?(Integer) || !addr.is_a?(Integer)
-      #     raise EvalError, "maybe stack too short"
-      #   end
-
-      #   at = addr + offset
-      #   data_end = at + 4 # sizeof(i32)
-      #   memory = self.instance.store.memories[0] || raise("[BUG] no memory")
-      #   memory.data[at...data_end] = [value].pack("I")
 
       when :call
         idx = insn.operand[0]
@@ -972,7 +372,93 @@ module Wardite
           end
           stack_unwind(old_frame.sp, old_frame.arity)
         end
+
+      when :drop
+        stack.pop
+
+      when :select
+        cond, right, left = stack.pop, stack.pop, stack.pop
+        if !cond.is_a?(I32)
+          raise EvalError, "invalid stack for select"
+        end
+        if !right || !left
+          raise EvalError, "stack too short"
+        end
+        stack.push(cond.value != 0 ? left : right)
+
+      when :local_get
+        idx = insn.operand[0]
+        if !idx.is_a?(Integer)
+          raise EvalError, "[BUG] invalid type of operand"
+        end
+        local = frame.locals[idx]
+        if !local
+          raise EvalError, "local not found"
+        end
+        stack.push(local)
+
+      when :local_set
+        idx = insn.operand[0]
+        if !idx.is_a?(Integer)
+          raise EvalError, "[BUG] invalid type of operand"
+        end
+        value = stack.pop
+        if !value
+          raise EvalError, "value should be pushed"
+        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))
+
+      when :memory_grow
+        delta = stack.pop
+        if !delta.is_a?(I32)
+          raise EvalError, "maybe stack too short"
+        end
+        memory = instance.store.memories[0] || raise("[BUG] no memory")
+        stack.push(I32(memory.grow(delta.value)))
+
+      else
+        raise "TODO! unsupported #{insn.inspect}"
       end
+
+    rescue => e
+      require "pp"
+      $stderr.puts "frame:::\n#{frame.pretty_inspect}"
+      $stderr.puts "stack:::\n#{stack.pretty_inspect}"
+      raise e
     end
 
     # @rbs ops: Array[Op]
@@ -1023,7 +509,7 @@ module Wardite
     end
 
     # @rbs finish: Integer
-    # @rbs return: Array[I32|I64|F32|F64|Block]
+    # @rbs return: Array[I32|I64|F32|F64]
     def drained_stack(finish)
       drained = stack[0...finish]
       if ! drained
@@ -1104,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)
@@ -1168,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
@@ -1179,21 +680,57 @@ module Wardite
   class Memory
     attr_accessor :data #: String
 
+    attr_accessor :current #: Integer
+
     attr_accessor :max #: Integer|nil
 
     # @rbs min: Integer
     # @rbs max: Integer|nil
     # @rbs return: void
     def initialize(min, max)
-      @data = String.new("\0" * (min * 64 * 1024), capacity: min * 64 * 1024)
+      @data = String.new("\0" * (min * 64 * 1024))
+      @current = min
       @max = max
     end
 
+    # @rbs delta: Integer
+    # @rbs return: Integer
+    def grow(delta)
+      prev = current
+      newsize = current + delta
+      if max && (newsize > max)
+        return -1
+      end
+      
+      @data += String.new("\0" * (delta * 64 * 1024))
+      prev
+    end
+
     def inspect
       "#<Wardite::Memory initial=#{@data.size.inspect} max=#{@max.inspect} @data=#{@data[0...64].inspect}...>"
     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
 
@@ -1317,6 +854,7 @@ module Wardite
   class LoadError < StandardError; end
   class ArgumentError < StandardError; end
   class EvalError < StandardError; end
+  class Unreachable < StandardError; end
 
   # @rbs path: String|nil
   # @rbs buffer: File|StringIO|nil