wardite 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 13e64d51eb1befe294c1ffe57e53b85cbeac7015c989e9fa88d7e3528f55c6df
+  data.tar.gz: ae6a11d049b3970b6f8f8f87a7fd07f1c69a367afe706296413797075c9b4c12
+SHA512:
+  metadata.gz: 8696f7f48858528a7b8d5ba524cdeada76ffde6fad9cd9009b8e1246ab51f0be5c6b0de511d4af29eef17a211d24602977fabe4bed31f63df925368317f664c6
+  data.tar.gz: 8d4e5e7b2931c2e04176099ad27b6d8bb65937cdada6abaaf7827674f83800373461344c4d8c9971e8f43b65abcf785466c88034331026c96d2139b8258b85d0

data/README.md

@@ -0,0 +1,35 @@
+# Wardite
+
+A pure-ruby webassembly runtime.
+
+## Installation
+
+TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test-unit` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/udzura/wardite.
+
+## See also
+
+- https://github.com/technohippy/wasmrb?tab=readme-ov-file
+  - Referencial implementation but no support with WASI
+  - Wardite aims to support full WASI (previwe 1)

data/Rakefile

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+desc "Run rbs-inline and steep"
+task :check do
+  sh "bundle exec rbs-inline --output lib/"
+  sh "bundle exec steep check"
+end
+
+task default: %i[test check]
+

data/Steepfile

@@ -0,0 +1,37 @@
+# -*- mode: ruby -*-
+target :lib do
+  signature "sig"
+  check "lib"
+
+  # configure_code_diagnostics(Steep::Diagnostic::Ruby.strict)
+end
+
+# D = Steep::Diagnostic
+#
+# target :lib do
+#   signature "sig"
+#
+#   check "lib"                       # Directory name
+#   check "Gemfile"                   # File name
+#   check "app/models/**/*.rb"        # Glob
+#   # ignore "lib/templates/*.rb"
+#
+#   # library "pathname"              # Standard libraries
+#   # library "strong_json"           # Gems
+#
+#   # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+#   # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+#   # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+#   # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+#   # configure_code_diagnostics do |hash|             # You can setup everything yourself
+#   #   hash[D::Ruby::NoMethod] = :information
+#   # end
+# end
+
+# target :test do
+#   signature "sig", "sig-private"
+#
+#   check "test"
+#
+#   # library "pathname"              # Standard libraries
+# end

data/examples/.gitignore

@@ -0,0 +1 @@
+*.wasm

data/examples/add.wat

@@ -0,0 +1,7 @@
+(module
+  (func (export "add") (param $a i32) (param $b i32) (result i32)
+    (local.get $a)
+    (local.get $b)
+    i32.add
+  )
+)

data/examples/call.wat

@@ -0,0 +1,11 @@
+(module
+  (func (export "call_doubler") (param i32) (result i32) 
+    (local.get 0)
+    (call $double)
+  )
+  (func $double (param i32) (result i32)
+    (local.get 0)
+    (local.get 0)
+    i32.add
+  )
+)

data/examples/helloworld.wat

@@ -0,0 +1,24 @@
+(module
+  (import "wasi_snapshot_preview1" "fd_write"
+    (func $fd_write (param i32 i32 i32 i32) (result i32))
+  )
+  (memory 1)
+  (data (i32.const 0) "Hello, World!\n")
+
+  (func $helloworld (result i32)
+    (local $iovs i32)
+
+    (i32.store (i32.const 16) (i32.const 0))
+    (i32.store (i32.const 20) (i32.const 14))
+
+    (local.set $iovs (i32.const 16))
+
+    (call $fd_write
+      (i32.const 1)
+      (local.get $iovs)
+      (i32.const 1)
+      (i32.const 24)
+    )
+  )
+  (export "_start" (func $helloworld))
+)

data/examples/i32_const.wat

@@ -0,0 +1,6 @@
+(module
+  (func $i32_const (result i32)
+    (i32.const 42)
+  )
+  (export "i32_const" (func $i32_const))
+)

data/examples/i32_store.wat

@@ -0,0 +1,9 @@
+(module
+  (memory 1)
+  (func $i32_store
+    (i32.const 0)
+    (i32.const 42)
+    (i32.store)
+  )
+  (export "i32_store" (func $i32_store))
+)

data/examples/local_set.wat

@@ -0,0 +1,8 @@
+(module
+  (func $local_set (result i32)
+    (local $x i32)
+    (local.set $x (i32.const 42))
+    (local.get 0)
+  )
+  (export "local_set" (func $local_set))
+)

data/examples/memory.wat

@@ -0,0 +1,5 @@
+(module
+  (memory 1)
+  (data (i32.const 0) "hello")
+  (data (i32.const 5) "world")
+)

data/exe/wardite

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "wardite"
+
+path = ARGV[0]
+method = ARGV[1]
+args = ARGV[2..-1] || []
+
+f = File.open(path)
+instance = Wardite::BinaryLoader::load_from_buffer(f);
+if !method && instance.runtime.respond_to?(:_start)
+  instance.runtime._start
+else
+  instance.runtime.call(method, args)
+end

data/lib/wardite/const.rb

@@ -0,0 +1,20 @@
+# rbs_inline: enabled
+module Wardite
+  module Const
+    # Section Code
+    # @see https://www.w3.org/TR/wasm-core-1/#sections%E2%91%A0
+    SectionCustom   = 0x0 #: Integer
+    SectionType     = 0x1 #: Integer
+    SectionImport   = 0x2 #: Integer
+    SectionFunction = 0x3 #: Integer
+    SectionTable    = 0x4 #: Integer
+    SectionMemory   = 0x5 #: Integer
+    SectionGlobal   = 0x6 #: Integer
+    SectionExport   = 0x7 #: Integer
+    SectionStart    = 0x8 #: Integer
+    SectionElement  = 0x9 #: Integer
+    SectionCode     = 0xa #: Integer
+    SectionData     = 0xb #: Integer
+  end
+  include Const
+end

data/lib/wardite/instruction.rb

@@ -0,0 +1,71 @@
+# rbs_inline: enabled
+module Wardite
+  class Op
+    attr_accessor :code #: Symbol
+
+    attr_accessor :operand #: Array[Object]
+
+    # @rbs code: Symbol
+    # @rbs operand: Array[Object]
+    def initialize(code, operand)
+      @code = code
+      @operand = operand
+    end
+
+    # @rbs chr: String
+    # @rbs return: Symbol
+    def self.to_sym(chr)
+      case chr
+      when "\u000b"
+        :end
+      when "\u0010"
+        :call
+      when "\u0020"
+        :local_get
+      when "\u0021"
+        :local_set
+      when "\u0036"
+        :i32_store
+      when "\u0041"
+        :i32_const
+      when "\u006a"
+        :i32_add
+      else
+        raise NotImplementedError, "unimplemented: #{chr.inspect}"
+      end
+    end
+
+    # @rbs chr: Symbol
+    # @rbs return: Array[Symbol]
+    def self.operand_of(code)
+      case code
+      when :local_get, :local_set, :call
+        [:u32]
+      when :i32_const
+        [:i32]
+      when :i32_store
+        [:u32, :u32]
+      else
+        []
+      end
+    end
+
+    # @see https://www.w3.org/TR/wasm-core-1/#value-types%E2%91%A2
+    # @rbs code: Integer
+    # @rbs return: Symbol
+    def self.i2type(code)
+      case code
+      when 0x7f
+        :i32
+      when 0x7e
+        :i64
+      when 0x7d
+        :f32
+      when 0x7c
+        :f64
+      else
+        raise "unknown type code #{code}"
+      end
+    end
+  end
+end

data/lib/wardite/leb128.rb

@@ -0,0 +1,58 @@
+# rbs_inline: enabled
+module Wardite
+  module Leb128Helpers
+    # @rbs buf: File|StringIO
+    # @rbs return: Integer
+    def fetch_uleb128(buf)
+      dest = 0
+      level = 0
+      while b = buf.read(1)
+        if b == nil
+          raise LoadError, "buffer too short"
+        end
+        c = b.ord
+
+        upper, lower = (c >> 7), (c & (1 << 7) - 1)
+        dest |= lower << (7 * level)
+        if upper == 0
+          return dest
+        end
+
+        if level > 6
+          break
+        end
+        level += 1
+      end
+      # unreachable but...
+      raise "unreachable! debug: dest = #{dest} level = #{level}"
+    end
+
+    # @rbs buf: File|StringIO
+    # @rbs return: Integer
+    def fetch_sleb128(buf)
+      dest = 0
+      level = 0
+      while b = buf.read(1)
+        if b == nil
+          raise LoadError, "buffer too short"
+        end
+        c = b.ord
+
+        upper, lower = (c >> 7), (c & (1 << 7) - 1)
+        dest |= lower << (7 * level)
+        if upper == 0
+          break
+        end
+
+        if level > 6
+          raise "unreachable! debug: dest = #{dest} level = #{level}"
+        end
+        level += 1
+      end
+      shift = 7 * (level + 1) - 1
+      return dest | -(dest & (1 << shift))   
+    end
+
+    module_function :fetch_uleb128, :fetch_sleb128
+  end
+end

data/lib/wardite/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Wardite
+  VERSION = "0.1.0" #: String
+end

data/lib/wardite/wasi.rb

@@ -0,0 +1,67 @@
+# rbs_inline: enabled
+module Wardite
+  class WasiSnapshotPreview1
+    attr_accessor :fd_table #: Array[IO]
+
+    def initialize
+      @fd_table = [
+        STDIN,
+        STDOUT,
+        STDERR,
+      ]
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[Object]
+    # @rbs return: Object
+    def fd_write(store, args)
+      iargs = args.map do |elm|
+        if elm.is_a?(Integer)
+          elm
+        else
+          raise Wardite::ArgumentError, "invalid type of args: #{args.inspect}"
+        end
+      end #: Array[Integer]
+      fd, iovs, iovs_len, rp = *iargs
+      if !fd || !iovs || !iovs_len || !rp
+        raise Wardite::ArgumentError, "args too short"
+      end
+      file = self.fd_table[fd]
+      memory = store.memories[0]
+      nwritten = 0
+      iovs_len.times do
+        start = unpack_le_int(memory.data[iovs...(iovs+4)])
+        iovs += 4
+        slen = unpack_le_int(memory.data[iovs...(iovs+4)])
+        iovs += 4
+        nwritten += file.write(memory.data[start...(start+slen)])
+      end
+
+      memory.data[rp...(rp+4)] = [nwritten].pack("I")
+
+      0
+    end
+
+
+    # @rbs return: Hash[Symbol, Proc]
+    def to_module
+      {
+        fd_write: lambda{|store, args| self.fd_write(store, args) },
+      }
+    end
+
+    private
+    # @rbs buf: String|nil
+    # @rbs return: Integer
+    def unpack_le_int(buf)
+      if !buf
+        raise "empty buffer"
+      end
+      ret = buf.unpack1("I")
+      if !ret.is_a?(Integer)
+        raise "[BUG] invalid pack format"
+      end
+      ret
+    end
+  end
+end