Module: Wardite::BinaryLoader

Extended by:

Leb128Helper, ValueHelper

Defined in:

lib/wardite.rb

Class Method Summary

• .assert_read(sbuf, n) ⇒ Object
• .code_body(buf) ⇒ Object
• .code_section ⇒ Object
• .data_section ⇒ Object
• .decode_expr(ops) ⇒ Object
• .export_section ⇒ Object
• .fetch_insn_while_end(sbuf) ⇒ Object
• .function_section ⇒ Object
• .import_section ⇒ Object
• .load_from_buffer(buf, import_object: {}, enable_wasi: true) ⇒ Object
• .memory_section ⇒ Object
• .preamble ⇒ Object
• .sections ⇒ Object
• .type_section ⇒ Object
• .unimplemented_skip_section(code) ⇒ Object

Methods included from Leb128Helper

fetch_sleb128, fetch_uleb128

Methods included from ValueHelper

F32, F64, I32, I64

Class Method Details

.assert_read(sbuf, n) ⇒ Object

# File 'lib/wardite.rb', line 568

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

.code_body(buf) ⇒ Object

# File 'lib/wardite.rb', line 427

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

.code_section ⇒ Object

# File 'lib/wardite.rb', line 388

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

.data_section ⇒ Object

# File 'lib/wardite.rb', line 462

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

.decode_expr(ops) ⇒ Object

# File 'lib/wardite.rb', line 510

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

.export_section ⇒ Object

# File 'lib/wardite.rb', line 529

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

.fetch_insn_while_end(sbuf) ⇒ Object

# File 'lib/wardite.rb', line 493

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

.function_section ⇒ Object

# File 'lib/wardite.rb', line 373

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

.import_section ⇒ Object

# File 'lib/wardite.rb', line 318

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

.load_from_buffer(buf, import_object: {}, enable_wasi: true) ⇒ Object

# File 'lib/wardite.rb', line 183

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

.memory_section ⇒ Object

# File 'lib/wardite.rb', line 349

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

.preamble ⇒ Object

# File 'lib/wardite.rb', line 201

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

.sections ⇒ Object

# File 'lib/wardite.rb', line 224

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

.type_section ⇒ Object

# File 'lib/wardite.rb', line 271

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

.unimplemented_skip_section(code) ⇒ Object

# File 'lib/wardite.rb', line 558

def self.unimplemented_skip_section(code)
  $stderr.puts "warning: unimplemented section: 0x0#{code}"
  size = @buf.read(1)&.ord
  @buf.read(size)
  nil
end