wardite 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89b6c42e1a3f16c39c214eb127c5b87966c0d2933257a1da7fdc96236c6a0f9b
-  data.tar.gz: 321d62cdddc61c8a342b966b3e4d7b6c01ffbbcb5788a6787fd3490ba96b1430
+  metadata.gz: bbf27d475ac9dac6a9c0f6284bf379858dfef4ee52f3a2d609f41e0a87110b46
+  data.tar.gz: 69d508dc6674117a0c94e8308b357e49a05952f17ac949470c53e8a3267442c2
 SHA512:
-  metadata.gz: 4b8b67989d47775828aca0908794f6b02abdea5ed653d794fa308d437f2d1735997a91dee341cdfa51aa5829aa097ca61dd262dba8479e805d1bbfd540f90ff5
-  data.tar.gz: 26face977ed4d76232bdee62f64208a22ec824314cb3d479979705fee327a1c9ce72ee960055a0c26db591f932c598b591651170fedf31b36533c52774f05fbe
+  metadata.gz: 9d1b5d0ed4b626ab9c34fd0aabedca56b48afa4e9629557e0fcc8d0c7a2e05ad57d674d630c4f4b1599ec1babf70082d2a21041890f6081d4fbe18b8e57c0789
+  data.tar.gz: ae55bd53d03c27a6626e320223389655adcfb67033d99bf9715171eb9bb90c718fab3eacefb2e8d9dd367f7c6d5c986f2bc956741da261d821ce102362b0898e

data/Steepfile

@@ -4,6 +4,7 @@ target :lib do
   check "lib"
 
   library "pp"
+  library "securerandom"
   # configure_code_diagnostics(Steep::Diagnostic::Ruby.strict)
 end
 

data/exe/wardite

@@ -1,16 +1,22 @@
 #!/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
+if instance.runtime.respond_to?(:_start) # assumed WASI
+  argv = ARGV[1..-1] || []
+  instance.wasi.argv = ["wardite"] + argv
+  Bundler.with_original_env do
+    # instance.store.memories[0].grow(128)
+    instance.runtime._start
+  end
 else
+  path = ARGV[0]
+  method = ARGV[1]
+  args = ARGV[2..-1] || []
+  
   args = args.map do|a|
     if a.include? "."
       a.to_f

data/lib/wardite/instruction.rb

@@ -46,16 +46,15 @@ module Wardite
 
     # @rbs @@table: Hash[Integer, Symbol] | nil
     @@table = nil
-    # @rbs @@table: Hash[Integer, Symbol] | nil
+    # @rbs @@fc_table: Hash[Integer, Symbol] | nil
     @@fc_table = nil
 
     # @rbs return: Hash[Integer, Symbol]
     def self.table
       return @@table if @@table != nil
-      @@table = {}.tap do |ha|
-        SYMS.each_with_index do |sym, i|
-          ha[i] = sym
-        end
+      @@table = {} #: Hash[Integer, Symbol] | nil
+      SYMS.each_with_index do |sym, i|
+        @@table[i] = sym
       end
       @@table
     end
@@ -63,10 +62,9 @@ module Wardite
     # @rbs return: Hash[Integer, Symbol]
     def self.fc_table
       return @@fc_table if @@fc_table != nil
-      @@fc_table = {}.tap do |ha|
-        FC_SYMS.each_with_index do |sym, i|
-          ha[i] = sym
-        end
+      @@fc_table = {} #: Hash[Integer, Symbol] | nil
+      FC_SYMS.each_with_index do |sym, i|
+        @@fc_table[i] = sym
       end
       @@fc_table
     end

data/lib/wardite/load.rb

@@ -250,7 +250,7 @@ module Wardite
     # @rbs self.@buf: File|StringIO
 
     # @rbs buf: File|StringIO
-    # @rbs import_object: Hash[Symbol, Hash[Symbol, wasmCallable]]
+    # @rbs import_object: Hash[Symbol, wasmModuleSrc]
     # @rbs enable_wasi: boolish
     # @rbs return: Instance
     def self.load_from_buffer(buf, import_object: {}, enable_wasi: true)
@@ -259,14 +259,19 @@ module Wardite
       version = preamble
       sections_ = sections
 
+      wasi_env = nil
       if enable_wasi
+        require "wardite/wasi"
         wasi_env = Wardite::WasiSnapshotPreview1.new       
-        import_object[:wasi_snapshot_preview1] = wasi_env.to_module
+        import_object[:wasi_snapshot_preview1] = wasi_env
       end
 
       return Instance.new(import_object) do |i|
         i.version = version
         i.sections = sections_
+        if enable_wasi
+          i.wasi = wasi_env
+        end
       end
     end
 
@@ -358,7 +363,7 @@ module Wardite
         end
 
         arglen = fetch_uleb128(sbuf)
-        arg = []
+        arg = [] #: Array[Symbol]
         arglen.times do
           case ty = assert_read(sbuf, 1)&.ord
           when 0x7f
@@ -376,7 +381,7 @@ module Wardite
         dest.defined_types << arg
 
         retlen = fetch_uleb128(sbuf)
-        ret = []
+        ret = [] #: Array[Symbol]
         retlen.times do
           case ty = assert_read(sbuf, 1)&.ord
           when 0x7f
@@ -482,7 +487,7 @@ module Wardite
           offset = decode_expr(ops)
           dest.table_offsets << offset
 
-          elms = []
+          elms = [] #: Array[Integer]
           elen = fetch_uleb128(sbuf)
           elen.times do |i|
             index = fetch_uleb128(sbuf)
@@ -585,8 +590,8 @@ module Wardite
           $stderr.puts "warning: instruction not ended with inst end(0x0b): 0x0#{last_code.ord}" 
         end
         cbuf = StringIO.new(code)
-        locals_count = []
-        locals_type = []
+        locals_count = [] #: Array[Integer]
+        locals_type = [] #: Array[Symbol]
         locals_len = fetch_uleb128(cbuf)
         locals_len.times do
           type_count = fetch_uleb128(cbuf)
@@ -610,7 +615,7 @@ module Wardite
     # @rbs buf: StringIO
     # @rbs return: Array[::Wardite::Op]
     def self.code_body(buf)
-      dest = []
+      dest = [] #: Array[Op]
       while c = buf.read(1)
         namespace, code = resolve_code(c, buf)
         operand_types = Op.operand_of(code)
@@ -855,7 +860,7 @@ module Wardite
     # @rbs code: Integer
     # @rbs return: nil
     def self.unimplemented_skip_section(code)
-      $stderr.puts "warning: unimplemented section: 0x0#{code}"
+      $stderr.puts "warning: unimplemented section: 0x0#{code}" if ENV['WARN_UNIMPLEMENTED_SECTION']
       size = fetch_uleb128(@buf)
       @buf.read(size)
       nil

data/lib/wardite/revisitor.rb

@@ -42,7 +42,7 @@ module Wardite
         case inst&.code
         when nil
           raise EvalError, "end op not found"
-        when :if
+        when :if, :block, :loop
           depth += 1
         when :else
           if depth == 0

data/lib/wardite/value.rb

@@ -8,20 +8,12 @@ module Wardite
     # @rbs value: Integer
     # @rbs return: I32
     def I32(value)
-      if value < 0
-        # $stderr.puts "trace: negative i32 value #{value} is passed, convert to unsigned"
-        value = as_u32(value)
-      end
-      I32.new.tap{|i| i.value = value & I32::I32_MAX }
+      I32.new(value & I32::I32_MAX)
     end
 
     # @rbs value: Integer
     # @rbs return: I64
     def I64(value)
-      if value < 0
-        # $stderr.puts "trace: negative i64 value #{value} is passed, convert to unsigned"
-        value = as_u64(value)
-      end
       I64.new.tap{|i| i.value = value & I64::I64_MAX }
     end
 
@@ -36,19 +28,6 @@ module Wardite
     def F64(value)
       F64.new.tap{|i| i.value = value }
     end
-
-    private
-    # @rbs value: Integer
-    # @rbs return: Integer
-    def as_u32(value)
-      ((-value) ^ I32::I32_MAX) + 1
-    end
-
-    # @rbs value: Integer
-    # @rbs return: Integer
-    def as_u64(value)
-      ((-value) ^ I64::I64_MAX) + 1
-    end
   end
 
   extend ValueHelper
@@ -61,6 +40,11 @@ module Wardite
     # when we want to access signed value, it'd be done via #value_s
     attr_accessor :value #: Integer
 
+    # @rbs value: Integer
+    def initialize(value=0)
+      @value = value
+    end
+
     # @rbs str: String
     # @rbs size: Integer|nil
     # @rbs signed: bool

data/lib/wardite/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Wardite
-  VERSION = "0.5.1" #: String
+  VERSION = "0.6.0" #: String
 end

data/lib/wardite/wasi/consts.rb

@@ -0,0 +1,129 @@
+# rbs_inline: enabled
+
+module Wardite
+  module Wasi
+    EACCES = 2
+    EAGAIN = 6
+    EBADF  = 8
+    EEXIST = 20
+    EFAULT = 21
+    EINTR  = 27
+    EINVAL = 28
+    EIO    = 29
+    EISDIR = 31
+    ELOOP  = 32
+    ENAMETOOLONG = 37
+    ENOENT = 44
+    ENOSYS = 52
+    ENOTDIR = 54
+    ERANGE  = 68
+    ENOTEMPTY = 55
+    ENOTSOCK = 57
+    ENOTSUP = 58
+    EPERM  = 63
+    EROFS  = 69
+
+    FILETYPE_UNKNOWN = 0
+    FILETYPE_BLOCK_DEVICE = 1 #: Integer
+    FILETYPE_CHARACTER_DEVICE = 2 #: Integer
+    FILETYPE_DIRECTORY = 3 #: Integer
+    FILETYPE_REGULAR_FILE = 4 #: Integer
+    FILETYPE_SOCKET_DGRAM = 5 #: Integer
+    FILETYPE_SOCKET_STREAM = 6 #: Integer
+    FILETYPE_SYMBOLIC_LINK = 7 #: Integer
+
+    FD_APPEND  = 1 << 0 #: Integer
+    FD_DSYNC   = 1 << 1 #: Integer
+    FD_NONBLOCK = 1 << 2 #: Integer
+    FD_RSYNC    = 1 << 3 #: Integer
+    FD_SYNC     = 1 << 4 #: Integer
+  
+    RIGHT_FD_DATASYNC = 1 << 0
+    RIGHT_FD_READ = 1 << 1
+    RIGHT_FD_SEEK = 1 << 2
+    RIGHT_FDSTAT_SET_FLAGS = 1 << 3
+    RIGHT_FD_SYNC = 1 << 4
+    RIGHT_FD_TELL = 1 << 5
+    RIGHT_FD_WRITE = 1 << 6
+    RIGHT_FD_ADVISE = 1 << 7
+    RIGHT_FD_ALLOCATE = 1 << 8
+    RIGHT_PATH_CREATE_DIRECTORY = 1 << 9
+    RIGHT_PATH_CREATE_FILE = 1 << 10
+    RIGHT_PATH_LINK_SOURCE = 1 << 11
+    RIGHT_PATH_LINK_TARGET = 1 << 12
+    RIGHT_PATH_OPEN = 1 << 13
+    RIGHT_FD_READDIR = 1 << 14
+    RIGHT_PATH_READLINK = 1 << 15
+    RIGHT_PATH_RENAME_SOURCE = 1 << 16
+    RIGHT_PATH_RENAME_TARGET = 1 << 17
+    RIGHT_PATH_FILESTAT_GET = 1 << 18
+    RIGHT_PATH_FILESTAT_SET_SIZE = 1 << 19
+    RIGHT_PATH_FILESTAT_SET_TIMES = 1 << 20
+    RIGHT_FD_FILESTAT_GET = 1 << 21
+    RIGHT_FD_FILESTAT_SET_SIZE = 1 << 22
+    RIGHT_FD_FILESTAT_SET_TIMES = 1 << 23
+    RIGHT_PATH_SYMLINK = 1 << 24
+    RIGHT_PATH_REMOVE_DIRECTORY = 1 << 25
+    RIGHT_PATH_UNLINK_FILE = 1 << 26
+    RIGHT_POLL_FD_READWRITE = 1 << 27
+    RIGHT_SOCK_SHUTDOWN = 1 << 28
+
+    RIGHT_FILE_RIGHT_BASE = RIGHT_FD_DATASYNC |
+      RIGHT_FD_READ |
+      RIGHT_FD_SEEK |
+      RIGHT_FDSTAT_SET_FLAGS |
+      RIGHT_FD_SYNC |
+      RIGHT_FD_TELL |
+      RIGHT_FD_WRITE |
+      RIGHT_FD_ADVISE |
+      RIGHT_FD_ALLOCATE |
+      RIGHT_FD_FILESTAT_GET |
+      RIGHT_FD_FILESTAT_SET_SIZE |
+      RIGHT_FD_FILESTAT_SET_TIMES |
+      RIGHT_POLL_FD_READWRITE
+  
+    RIGHT_DIR_RIGHT_BASE = RIGHT_FD_DATASYNC |
+      RIGHT_FDSTAT_SET_FLAGS |
+      RIGHT_FD_SYNC |
+      RIGHT_PATH_CREATE_DIRECTORY |
+      RIGHT_PATH_CREATE_FILE |
+      RIGHT_PATH_LINK_SOURCE |
+      RIGHT_PATH_LINK_TARGET |
+      RIGHT_PATH_OPEN |
+      RIGHT_FD_READDIR |
+      RIGHT_PATH_READLINK |
+      RIGHT_PATH_RENAME_SOURCE |
+      RIGHT_PATH_RENAME_TARGET |
+      RIGHT_PATH_FILESTAT_GET |
+      RIGHT_PATH_FILESTAT_SET_SIZE |
+      RIGHT_PATH_FILESTAT_SET_TIMES |
+      RIGHT_FD_FILESTAT_GET |
+      RIGHT_FD_FILESTAT_SET_TIMES |
+      RIGHT_PATH_SYMLINK |
+      RIGHT_PATH_REMOVE_DIRECTORY |
+      RIGHT_PATH_UNLINK_FILE
+
+    # @rbs mode_str: String
+    # @rbs return: Integer
+    def self.to_ftype(mode_str)
+      case mode_str
+      when "file"
+        FILETYPE_REGULAR_FILE
+      when "directory"
+        FILETYPE_DIRECTORY
+      when "characterSpecial"
+        FILETYPE_CHARACTER_DEVICE
+      when "blockSpecial"
+        FILETYPE_BLOCK_DEVICE
+      when "fifo"
+        FILETYPE_UNKNOWN
+      when "link"
+        FILETYPE_SYMBOLIC_LINK
+      when "socket"
+        FILETYPE_SOCKET_STREAM # TODO: check UDP
+      else
+        FILETYPE_UNKNOWN
+      end
+    end
+  end
+end

data/lib/wardite/wasi.rb

@@ -1,16 +1,161 @@
 # rbs_inline: enabled
+
+require "wardite/wasm_module"
+require "wardite/wasi/consts"
+require "securerandom"
+require "fcntl"
+
 module Wardite
   class WasiSnapshotPreview1
     include ValueHelper
+    include WasmModule
 
-    attr_accessor :fd_table #: Array[IO]
+    attr_accessor :fd_table #: Array[(IO|File)]
+    attr_accessor :argv #: Array[String]
 
-    def initialize
+    # @rbs argv: Array[String]
+    # @rbs return: void
+    def initialize(argv: [])
       @fd_table = [
         STDIN,
         STDOUT,
         STDERR,
       ]
+      @argv = argv
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def args_get(store, args)
+      arg_offsets_p = args[0].value
+      arg_data_buf_p = args[1].value
+      if !arg_data_buf_p.is_a?(Integer)
+        raise ArgumentError, "invalid type of args: #{args.inspect}"
+      end
+
+      arg_offsets = [] #: Array[Integer]
+      arg_data_slice = [] #: Array[String]
+      current_offset = arg_data_buf_p
+      @argv.each do |arg|
+        arg_offsets << current_offset
+        arg_data_slice << arg
+        current_offset += arg.size + 1
+      end
+      arg_data = arg_data_slice.join("\0") + "\0"
+
+      memory = store.memories[0]
+      memory.data[arg_data_buf_p...(arg_data_buf_p + arg_data.size)] = arg_data
+
+      arg_offsets.each_with_index do |offset, i|
+        data_begin = arg_offsets_p + i * 4
+        memory.data[data_begin...(data_begin + 4)] = [offset].pack("I!")
+      end
+
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def args_sizes_get(store, args)
+      argc_p = args[0].value
+      arglen_p = args[1].value
+      argc = @argv.length
+      arglen = @argv.map{|arg| arg.size + 1}.sum
+
+      memory = store.memories[0]
+      memory.data[argc_p...(argc_p+4)] = [argc].pack("I!")
+      memory.data[arglen_p...(arglen_p+4)] = [arglen].pack("I!")
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def environ_sizes_get(store, args)
+      envc_p = args[0].value
+      envlen_p = args[1].value
+      envc = ENV.length
+      envlen = ENV.map{|k,v| k.size + v.size + 1}.sum
+
+      memory = store.memories[0]
+      memory.data[envc_p...(envc_p+4)] = [envc].pack("I!")
+      memory.data[envlen_p...(envlen_p+4)] = [envlen].pack("I!")
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def environ_get(store, args)
+      environ_offsets_p = args[0].value
+      environ_data_buf_p = args[1].value
+      if !environ_data_buf_p.is_a?(Integer)
+        raise ArgumentError, "invalid type of args: #{args.inspect}"
+      end
+
+      environ_offsets = [] #: Array[Integer]
+      environ_data_slice = [] #: Array[String]
+      current_offset = environ_data_buf_p
+      ENV.each do |k, v|
+        environ_offsets << current_offset
+        environ_data_slice << "#{k}=#{v}"
+        current_offset += "#{k}=#{v}".size + 1
+      end
+      environ_data = environ_data_slice.join("\0") + "\0"
+
+      memory = store.memories[0]
+      memory.data[environ_data_buf_p...(environ_data_buf_p + environ_data.size)] = environ_data
+
+      environ_offsets.each_with_index do |offset, i|
+        data_begin = environ_offsets_p + i * 4
+        memory.data[data_begin...(data_begin + 4)] = [offset].pack("I!")
+      end
+
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def clock_time_get(store, args)
+      clock_id = args[0].value
+      # we dont use precision...
+      _precision = args[1].value
+      timebuf64 = args[2].value
+      if clock_id != 0 # - CLOCKID_REALTIME
+        # raise NotImplementedError, "CLOCKID_REALTIME is an only supported id"
+        return -255
+      end
+      # timestamp in nanoseconds
+      now = Time.now.to_i * 1_000_000
+
+      memory = store.memories[0]
+      now_packed = [now].pack("Q!")
+      memory.data[timebuf64...(timebuf64+8)] = now_packed
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def fd_prestat_get(store, args)
+      fd = args[0].value.to_i
+      prestat_offset = args[1].value.to_i
+      if fd >= @fd_table.size
+        return Wasi::EBADF
+      end
+      file = @fd_table[fd]
+      if !file.is_a?(File)
+        return Wasi::EBADF
+      end
+      name = file.path
+      memory = store.memories[0]
+      # Zero-value 8-bit tag, and 3-byte zero-value padding
+      memory.data[prestat_offset...(prestat_offset+4)] = [0].pack("I!")
+      memory.data[(prestat_offset+4)...(prestat_offset+8)] = [name.size].pack("I!")
+      0
     end
 
     # @rbs store: Store
@@ -29,6 +174,7 @@ module Wardite
         raise Wardite::ArgumentError, "args too short"
       end
       file = self.fd_table[fd]
+      return Wasi::EBADF if !file
       memory = store.memories[0]
       nwritten = 0
       iovs_len.times do
@@ -45,11 +191,126 @@ module Wardite
       0
     end
 
-    # @rbs return: Hash[Symbol, wasmCallable]
-    def to_module
-      {
-        fd_write: lambda{|store, args| self.fd_write(store, args) },
-      }
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def fd_read(store, args)
+      iargs = args.map do |elm|
+        if elm.is_a?(I32)
+          elm.value
+        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]
+      return Wasi::EBADF if !file
+      memory = store.memories[0]
+      nread = 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
+        buf = file.read(slen)
+        if !buf
+          return Wasi::EFAULT
+        end
+        memory.data[start...(start+slen)] = buf
+        nread += slen
+      end
+
+      memory.data[rp...(rp+4)] = [nread].pack("I!")
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def fd_fdstat_get(store, args)
+      fd = args[0].value.to_i
+      fdstat_offset = args[1].value.to_i
+      if fd >= @fd_table.size
+        return Wasi::EBADF
+      end
+      file = @fd_table[fd]
+      fdflags = 0
+      if file.is_a?(IO)
+        fdflags |= Wasi::FD_APPEND
+      else
+        if (Fcntl::O_APPEND & file.fcntl(Fcntl::F_GETFL, 0)) != 0
+          fdflags |= Wasi::FD_APPEND
+        end
+      end
+
+      if (Fcntl::O_NONBLOCK & file.fcntl(Fcntl::F_GETFL, 0)) != 0
+        fdflags |= Wasi::FD_NONBLOCK
+      end
+
+      stat = file.stat #: File::Stat
+      ftype = Wasi.to_ftype(stat.ftype)
+
+      fs_right_base = 0
+      fs_right_inheriting = 0
+
+      case ftype
+      when Wasi::FILETYPE_DIRECTORY
+        fs_right_base = Wasi::RIGHT_DIR_RIGHT_BASE
+        fs_right_inheriting = Wasi::RIGHT_FILE_RIGHT_BASE | Wasi::RIGHT_DIR_RIGHT_BASE
+      when Wasi::FILETYPE_CHARACTER_DEVICE
+        fs_right_base = Wasi::RIGHT_FILE_RIGHT_BASE & \
+          (~Wasi::RIGHT_FD_SEEK) & (~Wasi::RIGHT_FD_TELL)
+      else
+        fs_right_base = Wasi::RIGHT_FILE_RIGHT_BASE
+      end
+
+      memory = store.memories[0]
+
+      binformat = [fdflags, ftype, 0, 0, 0, 0, fs_right_base, fs_right_inheriting]
+        .pack("SSC4QQ")
+      memory.data[fdstat_offset...(fdstat_offset+binformat.size)] = binformat
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def fd_filestat_get(store, args)
+      fd = args[0].value.to_i
+      filestat_offset = args[1].value.to_i
+      if fd >= @fd_table.size
+        return Wasi::EBADF
+      end
+      file = @fd_table[fd]
+      stat = file.stat #: File::Stat
+      memory = store.memories[0]
+      binformat = [stat.dev, stat.ino, Wasi.to_ftype(stat.ftype), stat.nlink, stat.size, stat.atime.to_i, stat.mtime.to_i, stat.ctime.to_i].pack("Q8")
+      memory.data[filestat_offset...(filestat_offset+binformat.size)] = binformat
+      0
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def proc_exit(store, args)
+      exit_code = args[0].value
+      exit(exit_code)
+    end
+
+    # @rbs store: Store
+    # @rbs args: Array[wasmValue]
+    # @rbs return: Object
+    def random_get(store, args)
+      buf = args[0].value.to_i
+      buflen = args[1].value.to_i
+      randoms = SecureRandom.random_bytes(buflen) #: String
+      memory = store.memories[0]
+      memory.data[buf...(buf+buflen)] = randoms
+      0
     end
 
     private