wardite 0.2.1 → 0.3.0

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
 
@@ -620,13 +31,15 @@ module Wardite
 
     attr_accessor :runtime #: Runtime
 
+    attr_accessor :types #: Array[Type]
+
     attr_accessor :store #: Store
 
     attr_accessor :exports #: Exports
 
-    attr_reader :import_object #: Hash[Symbol, Hash[Symbol, Proc]]
+    attr_reader :import_object #: Hash[Symbol, Hash[Symbol, wasmCallable]]
 
-    # @rbs import_object: Hash[Symbol, Hash[Symbol, Proc]]
+    # @rbs import_object: Hash[Symbol, Hash[Symbol, wasmCallable]]
     # @rbs &blk: (Instance) -> void
     def initialize(import_object, &blk)
       blk.call(self)
@@ -635,6 +48,15 @@ module Wardite
       @store = Store.new(self)
       @exports = Exports.new(self.export_section, store)
       @runtime = Runtime.new(self)
+
+      @types = []
+      type_section = self.type_section
+      if type_section
+        type_section.defined_types.each_with_index do |calltype, idx|
+          rettype = type_section.defined_results[idx]
+          @types << Type.new(calltype, rettype)
+        end
+      end
     end
 
     # @rbs return: ImportSection
@@ -671,6 +93,30 @@ module Wardite
       sec
     end
 
+    # @rbs return: StartSection|nil
+    def start_section
+      sec = @sections.find{|s| s.code == Const::SectionStart }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(StartSection)
+        raise(GenericError, "[BUG] found invalid start section")
+      end
+      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 }
@@ -695,6 +141,30 @@ module Wardite
       sec
     end
 
+    # @rbs return: TableSection?
+    def table_section
+      sec = @sections.find{|s| s.code == Const::SectionTable }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(TableSection)
+        raise(GenericError, "instance doesn't have required section")
+      end
+      sec
+    end
+
+    # @rbs return: ElemSection?
+    def elem_section
+      sec = @sections.find{|s| s.code == Const::SectionElement }
+      if !sec
+        return nil
+      end
+      if !sec.is_a?(ElemSection)
+        raise(GenericError, "instance doesn't have required section")
+      end
+      sec
+    end
+
     # @rbs return: CodeSection|nil
     def code_section
       sec = @sections.find{|s| s.code == Const::SectionCode }
@@ -724,7 +194,7 @@ module Wardite
     include ValueHelper
 
     # TODO: add types of class that the stack accomodates
-    attr_accessor :stack #: Array[I32|I64|F32|F64]
+    attr_accessor :stack #: Array[wasmValue]
 
     attr_accessor :call_stack #: Array[Frame]
 
@@ -735,8 +205,18 @@ module Wardite
       @stack = []
       @call_stack = []
       @instance = inst
+
+      invoke_start_section
     end
 
+    # @rbs return: void
+    def invoke_start_section
+      start_section = instance.start_section
+      if start_section
+        call_by_index(start_section.func_index)
+      end
+    end
+    
     # @rbs name: String|Symbol
     # @rbs return: bool
     def callable?(name)
@@ -777,6 +257,21 @@ module Wardite
       end
     end
 
+    # @rbs idx: Integer
+    # @rbs return: void
+    def call_by_index(idx)
+      fn = @instance.store.funcs[idx]
+
+      case fn
+      when WasmFunction
+        invoke_internal(fn)
+      when ExternalFunction
+        invoke_external(fn)
+      else
+        raise GenericError, "registered pointer is not to a function"
+      end
+    end
+
     # @rbs wasm_function: WasmFunction
     # @rbs return: void
     def push_frame(wasm_function)
@@ -826,7 +321,7 @@ module Wardite
     end
 
     # @rbs external_function: ExternalFunction
-    # @rbs return: I32|I64|F32|F64|nil
+    # @rbs return: wasmValue|nil
     def invoke_external(external_function)
       local_start = stack.size - external_function.callsig.size
       args = stack[local_start..]
@@ -903,19 +398,80 @@ module Wardite
       when :nop
         return
 
+      when :br
+        level = insn.operand[0]
+        raise EvalError, "br op without level" if !level.is_a?(Integer)
+        pc = do_branch(frame.labels, stack, level)
+        frame.pc = pc
+
+      when :br_if
+        level = insn.operand[0]
+        raise EvalError, "br op without level" if !level.is_a?(Integer)
+        cond = stack.pop 
+        raise EvalError, "cond not found" if !cond.is_a?(I32)
+        if cond.value.zero?
+          return
+        end
+        pc = do_branch(frame.labels, stack, level)
+        frame.pc = pc
+
+      when :br_table
+        level_vec = insn.operand[0]
+        raise EvalError, "no level vector" if !level_vec.is_a?(Array)
+        default = insn.operand[1]
+        raise EvalError, "no default specified" if !default.is_a?(Integer)
+        idx = stack.pop 
+        raise EvalError, "idx not found" if !idx.is_a?(I32)
+        level = if idx.value_s < 0 || idx.value_s >= level_vec.size
+          default
+        else
+          level_vec[idx.value_s]
+        end
+        pc = do_branch(frame.labels, stack, level)
+        frame.pc = pc
+
+      when :block
+        block = insn.operand[0]
+        raise EvalError, "block op without block" if !block.is_a?(Block)
+        next_pc = fetch_ops_while_end(frame.body, frame.pc)
+        label = Label.new(:block, next_pc, stack.size, block.result_size)
+        frame.labels.push(label)
+
+      when :loop
+        block = insn.operand[0]
+        raise EvalError, "loop op without block" if !block.is_a?(Block)
+        start = frame.pc
+        end_pc = fetch_ops_while_end(frame.body, frame.pc)
+        label = Label.new(:loop, end_pc, stack.size, block.result_size, start)
+        frame.labels.push(label)
+
       when :if
         block = insn.operand[0]
         raise EvalError, "if op without block" if !block.is_a?(Block)
         cond = stack.pop 
         raise EvalError, "cond not found" if !cond.is_a?(I32)
         next_pc = fetch_ops_while_end(frame.body, frame.pc)
+
         if cond.value.zero?
-          frame.pc = next_pc
+          frame.pc = fetch_ops_while_else_or_end(frame.body, frame.pc)
+        end
+
+        if frame.pc == next_pc
+          # This means if block has no else instr.
+          return
         end
 
         label = Label.new(:if, next_pc, stack.size, block.result_size)
         frame.labels.push(label)
 
+      when :else
+        if old_label = frame.labels.pop
+          frame.pc = old_label.pc
+          stack_unwind(old_label.sp, old_label.arity)
+        else
+          raise EvalError, "else should be in if block"
+        end
+
       when :call
         idx = insn.operand[0]
         raise EvalError, "[BUG] local operand not found" if !idx.is_a?(Integer)
@@ -930,6 +486,45 @@ module Wardite
           raise GenericError, "got a non-function pointer"
         end
 
+      when :call_indirect
+        table = self.instance.store.tables[0]
+        raise EvalError, "table required but not found" if !table
+        type_idx = insn.operand[0]
+        raise EvalError, "[BUG] index operand invalid" if !type_idx.is_a?(Integer)
+        nullbyte = insn.operand[1]
+        raise EvalError, "[BUG] invalid bytearray of call_indirect" if nullbyte != 0x0
+        table_idx = stack.pop
+        raise EvalError, "[BUG] index stack invalid" if !table_idx.is_a?(I32)
+        fntype = self.instance.types[type_idx]
+        if !fntype
+          raise EvalError, "undefined type index: idx=#{type_idx}"          
+        end
+        refs = self.instance.store.tables[0]&.refs
+        if !refs
+           raise EvalError, "uninitialized element idx:#{table_idx}"
+        end
+
+        fn = refs[table_idx.value]
+        case fn
+        when WasmFunction
+          if table.type != :funcref
+            raise EvalError, "invalid type of elem; expected: #{table.type}"
+          end
+          fn = fn.clone(override_type: fntype)
+          push_frame(fn)
+        when ExternalFunction
+          if table.type != :externref
+            raise EvalError, "invalid type of elem; expected: #{table.type}"
+          end
+          fn = fn.clone(override_type: fntype)
+          ret = invoke_external(fn)
+          self.stack.push ret if ret
+        when nil
+          raise EvalError, "uninitialized element idx:#{table_idx.value}"
+        else
+          raise EvalError, "[BUG] unknwon function type #{fn}"
+        end
+
       when :return
         old_frame = call_stack.pop
         if !old_frame
@@ -985,6 +580,48 @@ module Wardite
         end
         frame.locals[idx] = value
 
+      when :local_tee
+        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
+        stack.push 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))
@@ -1003,11 +640,69 @@ module Wardite
 
     rescue => e
       require "pp"
+      $stderr.puts "instance:::\n#{self.instance.pretty_inspect}"
       $stderr.puts "frame:::\n#{frame.pretty_inspect}"
       $stderr.puts "stack:::\n#{stack.pretty_inspect}"
       raise e
     end
 
+    # @rbs ops: Array[Op]
+    # @rbs pc_start: Integer
+    # @rbs return: Integer
+    def fetch_ops_while_else_or_end(ops, pc_start)
+      cursor = pc_start
+      depth = 0
+      loop {
+        cursor += 1
+        inst = ops[cursor]
+        case inst&.code
+        when nil
+          raise EvalError, "end op not found"
+        when :if
+          depth += 1
+        when :else
+          if depth == 0
+            return cursor
+          end
+          # do not touch depth
+        when :end
+          if depth == 0
+            return cursor
+          else
+            depth -= 1
+          end
+        else
+          # nop
+        end
+      }
+      raise "[BUG] unreachable"
+    end
+
+    # @rbs labels: Array[Label]
+    # @rbs stack: Array[wasmValue]
+    # @rbs level: Integer
+    # @rbs return: Integer
+    def do_branch(labels, stack, level)
+      idx = labels.size - 1 - level
+      label = labels[idx]
+      pc = if label.kind == :loop
+        # keep the top of labels for loop again...
+        while labels.size > idx + 1
+          labels.pop
+        end
+        stack_unwind(label.sp, 0)
+        label.start || raise(EvalError, "loop withour start")
+      else
+        while labels.size > idx
+          labels.pop
+        end
+        stack_unwind(label.sp, label.arity)
+        label.pc
+      end
+
+      pc
+    end
+
     # @rbs ops: Array[Op]
     # @rbs pc_start: Integer
     # @rbs return: Integer
@@ -1020,7 +715,7 @@ module Wardite
         case inst&.code
         when nil
           raise EvalError, "end op not found"
-        when :i
+        when :if, :block, :loop
           depth += 1
         when :end
           if depth == 0
@@ -1056,7 +751,7 @@ module Wardite
     end
 
     # @rbs finish: Integer
-    # @rbs return: Array[I32|I64|F32|F64]
+    # @rbs return: Array[wasmValue]
     def drained_stack(finish)
       drained = stack[0...finish]
       if ! drained
@@ -1084,6 +779,20 @@ module Wardite
     end
   end
 
+  class Type
+    attr_accessor :callsig #: Array[Symbol]
+
+    attr_accessor :retsig #: Array[Symbol]
+
+    # @rbs callsig: Array[Symbol]
+    # @rbs retsig: Array[Symbol]
+    # @rbs returb: void
+    def initialize(callsig, retsig)
+      @callsig = callsig
+      @retsig = retsig
+    end
+  end
+
   class Frame
     attr_accessor :pc #: Integer
     attr_accessor :sp #: Integer
@@ -1094,13 +803,13 @@ module Wardite
 
     attr_accessor :labels #: Array[Label]
 
-    attr_accessor :locals #: Array[I32|I64|F32|F64]
+    attr_accessor :locals #: Array[wasmValue]
 
     # @rbs pc: Integer
     # @rbs sp: Integer
     # @rbs body: Array[Op]
     # @rbs arity: Integer
-    # @rbs locals: Array[Object]
+    # @rbs locals: Array[wasmValue]
     # @rbs returb: void
     def initialize(pc, sp, body, arity, locals)
       @pc = pc
@@ -1120,16 +829,20 @@ module Wardite
 
     attr_accessor :arity #: Integer
 
+    attr_accessor :start #: Integer|nil
+
     # @rbs kind: (:if|:loop|:block)
     # @rbs pc: Integer
     # @rbs sp: Integer
     # @rbs arity: Integer
-    # @rbs returb: void
-    def initialize(kind, pc, sp, arity)
+    # @rbs start: Integer|nil
+    # @rbs return: void
+    def initialize(kind, pc, sp, arity, start=nil)
       @kind = kind
       @pc = pc
       @sp = sp
       @arity = arity
+      @start = start
     end
   end
 
@@ -1137,9 +850,15 @@ module Wardite
     attr_accessor :funcs #: Array[WasmFunction|ExternalFunction]
 
     # FIXME: attr_accessor :modules
-     
+
     attr_accessor :memories #: Array[Memory]
 
+    attr_accessor :globals #: Array[Global]
+
+    attr_accessor :tables #: Array[Table]
+
+    attr_accessor :elements #: Array[[Symbol, Integer, Array[Integer]]]
+
     # @rbs inst: Instance
     # @rbs return: void
     def initialize(inst)
@@ -1201,6 +920,69 @@ 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
+
+      @tables = []
+      @elements = []
+      table_section = inst.table_section
+      if table_section
+        table_section.table_types.each_with_index do |typ, idx|
+          init, max = *table_section.table_limits[idx]
+          if !init
+            raise LoadError, "empty limits"
+          end
+          table = Table.new(typ, init, max)
+          @tables << table
+        end
+      end
+
+      elem_section = inst.elem_section
+      if elem_section
+        elem_section.table_indices.each_with_index do |tidx, idx|
+          table = @tables[tidx]
+          if !table
+            raise LoadError, "invalid table index #{tidx}"
+          end
+          typ = table.type
+          offset = elem_section.table_offsets[idx]
+          if !offset
+            raise LoadError, "invalid element index #{idx}"
+          end
+          indices = elem_section.element_indices[idx]
+          if !indices
+            raise LoadError, "invalid element index #{idx}"
+          end
+          elms = [typ, offset, indices] #: [Symbol, Integer, Array[Integer]]
+          @elements << elms
+        end
+      end
+
+      @elements.each_with_index do |(typ, offset, indices), idx|
+        table = @tables[idx]
+        if !table
+          raise LoadError, "invalid table index #{idx}"          
+        end
+        indices.each_with_index do |eidx, tidx|
+          case typ
+          when :funcref
+            table.set(offset + tidx, @funcs[eidx])
+          when :externref
+            raise NotImplementedError, "no support :externref"
+          end
+        end
+      end
     end
 
     # @rbs idx: Integer
@@ -1243,6 +1025,58 @@ module Wardite
     end
   end
 
+  class Table
+    attr_accessor :type #: Symbol
+    
+    attr_accessor :current #: Integer
+
+    attr_accessor :max #: Integer|nil
+    
+    attr_accessor :refs #: Array[WasmFunction|ExternalFunction|nil]
+
+    # @rbs type: Symbol
+    # @rbs init: Integer
+    # @rbs max: Integer|nil
+    # @rbs return: void
+    def initialize(type, init, max)
+      @type = type
+      @current = init
+      @max = max
+
+      @refs = Array.new(3, nil)
+    end
+
+    # @rbs idx: Integer
+    # @rbs elem: WasmFunction|ExternalFunction|nil
+    # @rbs return: void
+    def set(idx, elem)
+      if idx >= @current
+        raise GenericError, "idx too large for table"
+      end
+      @refs[idx] = elem
+    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 #: wasmValue
+
+    # @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
 
@@ -1341,25 +1175,51 @@ module Wardite
     # @rbs return: Array[Integer]
     def locals_count
       code_body.locals_count
-    end    
+    end
+
+    # @rbs override_type: Type?
+    # @rbs return: WasmFunction
+    def clone(override_type: nil)
+      if override_type
+        # code_body is assumed to be frozen, so we can copy its ref
+        WasmFunction.new(override_type.callsig, override_type.retsig, code_body)
+      else
+        WasmFunction.new(callsig, retsig, code_body)
+      end
+    end
   end
 
+  # @rbs!
+  #   type wasmFuncReturn = Object|nil
+  #   type wasmCallable = ^(Store, Array[wasmValue]) -> wasmFuncReturn
+
   class ExternalFunction
     attr_accessor :callsig #: Array[Symbol]
 
     attr_accessor :retsig #: Array[Symbol]
 
-    attr_accessor :callable #: Proc
+    attr_accessor :callable #: wasmCallable
 
     # @rbs callsig: Array[Symbol]
     # @rbs retsig: Array[Symbol]
-    # @rbs callable: Proc
+    # @rbs callable: wasmCallable
     # @rbs return: void
     def initialize(callsig, retsig, callable)
       @callsig = callsig
       @retsig = retsig
       @callable = callable
     end
+
+    # @rbs override_type: Type?
+    # @rbs return: ExternalFunction
+    def clone(override_type: nil)
+      if override_type
+        # callable is assumed to be frozen, so we can copy its ref
+        ExternalFunction.new(override_type.callsig, override_type.retsig, callable)
+      else
+        ExternalFunction.new(callsig, retsig, callable)
+      end
+    end
   end
 
   class GenericError < StandardError; end