js 0.0.1 → 2.4.1.pre.1

data/ext/witapi/bindgen/rb-abi-guest.c

@@ -0,0 +1,222 @@
+#include <stdlib.h>
+#include <rb-abi-guest.h>
+
+__attribute__((weak, export_name("cabi_realloc")))
+void *cabi_realloc(
+void *ptr,
+size_t orig_size,
+size_t org_align,
+size_t new_size
+) {
+  void *ret = realloc(ptr, new_size);
+  if (!ret)
+  abort();
+  return ret;
+}
+
+__attribute__((import_module("canonical_abi"), import_name("resource_drop_rb-iseq")))
+void __resource_rb_iseq_drop(uint32_t idx);
+
+void rb_abi_guest_rb_iseq_free(rb_abi_guest_rb_iseq_t *ptr) {
+  __resource_rb_iseq_drop(ptr->idx);
+}
+
+__attribute__((import_module("canonical_abi"), import_name("resource_clone_rb-iseq")))
+uint32_t __resource_rb_iseq_clone(uint32_t idx);
+
+rb_abi_guest_rb_iseq_t rb_abi_guest_rb_iseq_clone(rb_abi_guest_rb_iseq_t *ptr) {
+  return (rb_abi_guest_rb_iseq_t){__resource_rb_iseq_clone(ptr->idx)};
+}
+
+__attribute__((import_module("canonical_abi"), import_name("resource_new_rb-iseq")))
+uint32_t __resource_rb_iseq_new(uint32_t val);
+
+rb_abi_guest_rb_iseq_t rb_abi_guest_rb_iseq_new(void *data) {
+  return (rb_abi_guest_rb_iseq_t){__resource_rb_iseq_new((uint32_t) data)};
+}
+
+__attribute__((import_module("canonical_abi"), import_name("resource_get_rb-iseq")))
+uint32_t __resource_rb_iseq_get(uint32_t idx);
+
+void* rb_abi_guest_rb_iseq_get(rb_abi_guest_rb_iseq_t *ptr) {
+  return (void*) __resource_rb_iseq_get(ptr->idx);
+}
+
+__attribute__((export_name("canonical_abi_drop_rb-iseq")))
+void __resource_rb_iseq_dtor(uint32_t val) {
+  if (rb_abi_guest_rb_iseq_dtor)
+  rb_abi_guest_rb_iseq_dtor((void*) val);
+}
+
+__attribute__((import_module("canonical_abi"), import_name("resource_drop_rb-abi-value")))
+void __resource_rb_abi_value_drop(uint32_t idx);
+
+void rb_abi_guest_rb_abi_value_free(rb_abi_guest_rb_abi_value_t *ptr) {
+  __resource_rb_abi_value_drop(ptr->idx);
+}
+
+__attribute__((import_module("canonical_abi"), import_name("resource_clone_rb-abi-value")))
+uint32_t __resource_rb_abi_value_clone(uint32_t idx);
+
+rb_abi_guest_rb_abi_value_t rb_abi_guest_rb_abi_value_clone(rb_abi_guest_rb_abi_value_t *ptr) {
+  return (rb_abi_guest_rb_abi_value_t){__resource_rb_abi_value_clone(ptr->idx)};
+}
+
+__attribute__((import_module("canonical_abi"), import_name("resource_new_rb-abi-value")))
+uint32_t __resource_rb_abi_value_new(uint32_t val);
+
+rb_abi_guest_rb_abi_value_t rb_abi_guest_rb_abi_value_new(void *data) {
+  return (rb_abi_guest_rb_abi_value_t){__resource_rb_abi_value_new((uint32_t) data)};
+}
+
+__attribute__((import_module("canonical_abi"), import_name("resource_get_rb-abi-value")))
+uint32_t __resource_rb_abi_value_get(uint32_t idx);
+
+void* rb_abi_guest_rb_abi_value_get(rb_abi_guest_rb_abi_value_t *ptr) {
+  return (void*) __resource_rb_abi_value_get(ptr->idx);
+}
+
+__attribute__((export_name("canonical_abi_drop_rb-abi-value")))
+void __resource_rb_abi_value_dtor(uint32_t val) {
+  if (rb_abi_guest_rb_abi_value_dtor)
+  rb_abi_guest_rb_abi_value_dtor((void*) val);
+}
+#include <string.h>
+
+void rb_abi_guest_string_set(rb_abi_guest_string_t *ret, const char *s) {
+  ret->ptr = (char*) s;
+  ret->len = strlen(s);
+}
+
+void rb_abi_guest_string_dup(rb_abi_guest_string_t *ret, const char *s) {
+  ret->len = strlen(s);
+  ret->ptr = cabi_realloc(NULL, 0, 1, ret->len);
+  memcpy(ret->ptr, s, ret->len);
+}
+
+void rb_abi_guest_string_free(rb_abi_guest_string_t *ret) {
+  if (ret->len > 0) {
+    free(ret->ptr);
+  }
+  ret->ptr = NULL;
+  ret->len = 0;
+}
+void rb_abi_guest_list_string_free(rb_abi_guest_list_string_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+    rb_abi_guest_string_free(&ptr->ptr[i]);
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+void rb_abi_guest_tuple2_rb_abi_value_s32_free(rb_abi_guest_tuple2_rb_abi_value_s32_t *ptr) {
+  rb_abi_guest_rb_abi_value_free(&ptr->f0);
+}
+void rb_abi_guest_list_rb_abi_value_free(rb_abi_guest_list_rb_abi_value_t *ptr) {
+  for (size_t i = 0; i < ptr->len; i++) {
+    rb_abi_guest_rb_abi_value_free(&ptr->ptr[i]);
+  }
+  if (ptr->len > 0) {
+    free(ptr->ptr);
+  }
+}
+
+__attribute__((aligned(4)))
+static uint8_t RET_AREA[8];
+__attribute__((export_name("ruby-show-version: func() -> ()")))
+void __wasm_export_rb_abi_guest_ruby_show_version(void) {
+  rb_abi_guest_ruby_show_version();
+}
+__attribute__((export_name("ruby-init: func() -> ()")))
+void __wasm_export_rb_abi_guest_ruby_init(void) {
+  rb_abi_guest_ruby_init();
+}
+__attribute__((export_name("ruby-sysinit: func(args: list<string>) -> ()")))
+void __wasm_export_rb_abi_guest_ruby_sysinit(int32_t arg, int32_t arg0) {
+  rb_abi_guest_list_string_t arg1 = (rb_abi_guest_list_string_t) { (rb_abi_guest_string_t*)(arg), (size_t)(arg0) };
+  rb_abi_guest_ruby_sysinit(&arg1);
+}
+__attribute__((export_name("ruby-options: func(args: list<string>) -> handle<rb-iseq>")))
+int32_t __wasm_export_rb_abi_guest_ruby_options(int32_t arg, int32_t arg0) {
+  rb_abi_guest_list_string_t arg1 = (rb_abi_guest_list_string_t) { (rb_abi_guest_string_t*)(arg), (size_t)(arg0) };
+  rb_abi_guest_rb_iseq_t ret = rb_abi_guest_ruby_options(&arg1);
+  return (ret).idx;
+}
+__attribute__((export_name("ruby-script: func(name: string) -> ()")))
+void __wasm_export_rb_abi_guest_ruby_script(int32_t arg, int32_t arg0) {
+  rb_abi_guest_string_t arg1 = (rb_abi_guest_string_t) { (char*)(arg), (size_t)(arg0) };
+  rb_abi_guest_ruby_script(&arg1);
+}
+__attribute__((export_name("ruby-init-loadpath: func() -> ()")))
+void __wasm_export_rb_abi_guest_ruby_init_loadpath(void) {
+  rb_abi_guest_ruby_init_loadpath();
+}
+__attribute__((export_name("rb-eval-string-protect: func(str: string) -> tuple<handle<rb-abi-value>, s32>")))
+int32_t __wasm_export_rb_abi_guest_rb_eval_string_protect(int32_t arg, int32_t arg0) {
+  rb_abi_guest_string_t arg1 = (rb_abi_guest_string_t) { (char*)(arg), (size_t)(arg0) };
+  rb_abi_guest_tuple2_rb_abi_value_s32_t ret;
+  rb_abi_guest_rb_eval_string_protect(&arg1, &ret);
+  int32_t ptr = (int32_t) &RET_AREA;
+  *((int32_t*)(ptr + 0)) = ((ret).f0).idx;
+  *((int32_t*)(ptr + 4)) = (ret).f1;
+  return ptr;
+}
+__attribute__((export_name("rb-funcallv-protect: func(recv: handle<rb-abi-value>, mid: u32, args: list<handle<rb-abi-value>>) -> tuple<handle<rb-abi-value>, s32>")))
+int32_t __wasm_export_rb_abi_guest_rb_funcallv_protect(int32_t arg, int32_t arg0, int32_t arg1, int32_t arg2) {
+  rb_abi_guest_list_rb_abi_value_t arg3 = (rb_abi_guest_list_rb_abi_value_t) { (rb_abi_guest_rb_abi_value_t*)(arg1), (size_t)(arg2) };
+  rb_abi_guest_tuple2_rb_abi_value_s32_t ret;
+  rb_abi_guest_rb_funcallv_protect((rb_abi_guest_rb_abi_value_t){ arg }, (uint32_t) (arg0), &arg3, &ret);
+  int32_t ptr = (int32_t) &RET_AREA;
+  *((int32_t*)(ptr + 0)) = ((ret).f0).idx;
+  *((int32_t*)(ptr + 4)) = (ret).f1;
+  return ptr;
+}
+__attribute__((export_name("rb-intern: func(name: string) -> u32")))
+int32_t __wasm_export_rb_abi_guest_rb_intern(int32_t arg, int32_t arg0) {
+  rb_abi_guest_string_t arg1 = (rb_abi_guest_string_t) { (char*)(arg), (size_t)(arg0) };
+  rb_abi_guest_rb_id_t ret = rb_abi_guest_rb_intern(&arg1);
+  return (int32_t) (ret);
+}
+__attribute__((export_name("rb-errinfo: func() -> handle<rb-abi-value>")))
+int32_t __wasm_export_rb_abi_guest_rb_errinfo(void) {
+  rb_abi_guest_rb_abi_value_t ret = rb_abi_guest_rb_errinfo();
+  return (ret).idx;
+}
+__attribute__((export_name("rb-clear-errinfo: func() -> ()")))
+void __wasm_export_rb_abi_guest_rb_clear_errinfo(void) {
+  rb_abi_guest_rb_clear_errinfo();
+}
+__attribute__((export_name("rstring-ptr: func(value: handle<rb-abi-value>) -> string")))
+int32_t __wasm_export_rb_abi_guest_rstring_ptr(int32_t arg) {
+  rb_abi_guest_string_t ret;
+  rb_abi_guest_rstring_ptr((rb_abi_guest_rb_abi_value_t){ arg }, &ret);
+  int32_t ptr = (int32_t) &RET_AREA;
+  *((int32_t*)(ptr + 4)) = (int32_t) (ret).len;
+  *((int32_t*)(ptr + 0)) = (int32_t) (ret).ptr;
+  return ptr;
+}
+__attribute__((export_name("cabi_post_rstring-ptr")))
+void __wasm_export_rb_abi_guest_rstring_ptr_post_return(int32_t arg0) {
+  if ((*((int32_t*) (arg0 + 4))) > 0) {
+    free((void*) (*((int32_t*) (arg0 + 0))));
+  }
+}
+__attribute__((export_name("rb-vm-bugreport: func() -> ()")))
+void __wasm_export_rb_abi_guest_rb_vm_bugreport(void) {
+  rb_abi_guest_rb_vm_bugreport();
+}
+__attribute__((export_name("rb-gc-enable: func() -> bool")))
+int32_t __wasm_export_rb_abi_guest_rb_gc_enable(void) {
+  bool ret = rb_abi_guest_rb_gc_enable();
+  return ret;
+}
+__attribute__((export_name("rb-gc-disable: func() -> bool")))
+int32_t __wasm_export_rb_abi_guest_rb_gc_disable(void) {
+  bool ret = rb_abi_guest_rb_gc_disable();
+  return ret;
+}
+__attribute__((export_name("rb-set-should-prohibit-rewind: func(new-value: bool) -> bool")))
+int32_t __wasm_export_rb_abi_guest_rb_set_should_prohibit_rewind(int32_t arg) {
+  bool ret = rb_abi_guest_rb_set_should_prohibit_rewind(arg);
+  return ret;
+}

data/ext/witapi/bindgen/rb-abi-guest.h

@@ -0,0 +1,77 @@
+#ifndef __BINDINGS_RB_ABI_GUEST_H
+#define __BINDINGS_RB_ABI_GUEST_H
+#ifdef __cplusplus
+extern "C"
+{
+  #endif
+  
+  #include <stdint.h>
+  #include <stdbool.h>
+  
+  typedef struct {
+    uint32_t idx;
+  } rb_abi_guest_rb_iseq_t;
+  void rb_abi_guest_rb_iseq_free(rb_abi_guest_rb_iseq_t *ptr);
+  rb_abi_guest_rb_iseq_t rb_abi_guest_rb_iseq_clone(rb_abi_guest_rb_iseq_t *ptr);
+  rb_abi_guest_rb_iseq_t rb_abi_guest_rb_iseq_new(void *data);
+  void* rb_abi_guest_rb_iseq_get(rb_abi_guest_rb_iseq_t *ptr);
+  
+  __attribute__((weak))
+  void rb_abi_guest_rb_iseq_dtor(void *data);
+  
+  typedef struct {
+    uint32_t idx;
+  } rb_abi_guest_rb_abi_value_t;
+  void rb_abi_guest_rb_abi_value_free(rb_abi_guest_rb_abi_value_t *ptr);
+  rb_abi_guest_rb_abi_value_t rb_abi_guest_rb_abi_value_clone(rb_abi_guest_rb_abi_value_t *ptr);
+  rb_abi_guest_rb_abi_value_t rb_abi_guest_rb_abi_value_new(void *data);
+  void* rb_abi_guest_rb_abi_value_get(rb_abi_guest_rb_abi_value_t *ptr);
+  
+  __attribute__((weak))
+  void rb_abi_guest_rb_abi_value_dtor(void *data);
+  
+  typedef struct {
+    char *ptr;
+    size_t len;
+  } rb_abi_guest_string_t;
+  
+  void rb_abi_guest_string_set(rb_abi_guest_string_t *ret, const char *s);
+  void rb_abi_guest_string_dup(rb_abi_guest_string_t *ret, const char *s);
+  void rb_abi_guest_string_free(rb_abi_guest_string_t *ret);
+  typedef int32_t rb_abi_guest_rb_errno_t;
+  typedef uint32_t rb_abi_guest_rb_id_t;
+  typedef struct {
+    rb_abi_guest_string_t *ptr;
+    size_t len;
+  } rb_abi_guest_list_string_t;
+  void rb_abi_guest_list_string_free(rb_abi_guest_list_string_t *ptr);
+  typedef struct {
+    rb_abi_guest_rb_abi_value_t f0;
+    int32_t f1;
+  } rb_abi_guest_tuple2_rb_abi_value_s32_t;
+  void rb_abi_guest_tuple2_rb_abi_value_s32_free(rb_abi_guest_tuple2_rb_abi_value_s32_t *ptr);
+  typedef struct {
+    rb_abi_guest_rb_abi_value_t *ptr;
+    size_t len;
+  } rb_abi_guest_list_rb_abi_value_t;
+  void rb_abi_guest_list_rb_abi_value_free(rb_abi_guest_list_rb_abi_value_t *ptr);
+  void rb_abi_guest_ruby_show_version(void);
+  void rb_abi_guest_ruby_init(void);
+  void rb_abi_guest_ruby_sysinit(rb_abi_guest_list_string_t *args);
+  rb_abi_guest_rb_iseq_t rb_abi_guest_ruby_options(rb_abi_guest_list_string_t *args);
+  void rb_abi_guest_ruby_script(rb_abi_guest_string_t *name);
+  void rb_abi_guest_ruby_init_loadpath(void);
+  void rb_abi_guest_rb_eval_string_protect(rb_abi_guest_string_t *str, rb_abi_guest_tuple2_rb_abi_value_s32_t *ret0);
+  void rb_abi_guest_rb_funcallv_protect(rb_abi_guest_rb_abi_value_t recv, rb_abi_guest_rb_id_t mid, rb_abi_guest_list_rb_abi_value_t *args, rb_abi_guest_tuple2_rb_abi_value_s32_t *ret0);
+  rb_abi_guest_rb_id_t rb_abi_guest_rb_intern(rb_abi_guest_string_t *name);
+  rb_abi_guest_rb_abi_value_t rb_abi_guest_rb_errinfo(void);
+  void rb_abi_guest_rb_clear_errinfo(void);
+  void rb_abi_guest_rstring_ptr(rb_abi_guest_rb_abi_value_t value, rb_abi_guest_string_t *ret0);
+  void rb_abi_guest_rb_vm_bugreport(void);
+  bool rb_abi_guest_rb_gc_enable(void);
+  bool rb_abi_guest_rb_gc_disable(void);
+  bool rb_abi_guest_rb_set_should_prohibit_rewind(bool new_value);
+  #ifdef __cplusplus
+}
+#endif
+#endif

data/ext/witapi/bindgen/rb-abi-guest.wit

@@ -0,0 +1,25 @@
+resource rb-iseq
+resource rb-abi-value
+type rb-errno = s32
+type rb-id = u32
+
+ruby-show-version: func()
+ruby-init: func()
+ruby-sysinit: func(args: list<string>)
+ruby-options: func(args: list<string>) -> rb-iseq
+ruby-script: func(name: string)
+ruby-init-loadpath: func()
+rb-eval-string-protect: func(str: string) -> tuple<rb-abi-value, s32>
+rb-funcallv-protect: func(recv: rb-abi-value, mid: rb-id, args: list<rb-abi-value>) -> tuple<rb-abi-value, s32>
+rb-intern: func(name: string) -> rb-id
+rb-errinfo: func() -> rb-abi-value
+rb-clear-errinfo: func()
+
+rstring-ptr: func(value: rb-abi-value) -> string
+
+rb-vm-bugreport: func()
+
+rb-gc-enable: func() -> bool
+rb-gc-disable: func() -> bool
+
+rb-set-should-prohibit-rewind: func(new-value: bool) -> bool

data/ext/witapi/depend

@@ -0,0 +1,11 @@
+link.filelist:
+	echo $(foreach obj,$(OBJS),$(abspath $(obj))) > $@
+	echo -mexec-model=reactor >> $@
+
+witapi.a: link.filelist
+
+witapi-core.o: $(srcdir)/bindgen/rb-abi-guest.h
+
+bindgen/%.o: $(srcdir)/bindgen/%.c
+	@mkdir -p "$(@D)"
+	$(CC) -c -I$(srcdir)/bindgen -o $@ $<

data/ext/witapi/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+$objs = %w[witapi-core.o bindgen/rb-abi-guest.o]
+create_makefile("witapi")

data/ext/witapi/witapi-core.c

@@ -0,0 +1,325 @@
+#include <stdlib.h>
+
+#include "ruby.h"
+#include "ruby/version.h"
+
+static VALUE rb_eval_string_value_protect_thunk(VALUE str) {
+  const ID id_eval = rb_intern("eval");
+  VALUE binding = rb_const_get(rb_cObject, rb_intern("TOPLEVEL_BINDING"));
+  const VALUE file = rb_utf8_str_new("eval", 4);
+  VALUE args[3] = {str, binding, file};
+  return rb_funcallv(rb_mKernel, id_eval, 3, args);
+}
+
+static VALUE rb_eval_string_value_protect(VALUE str, int *pstate) {
+  return rb_protect(rb_eval_string_value_protect_thunk, str, pstate);
+}
+
+#define TAG_NONE 0
+
+#include "bindgen/rb-abi-guest.h"
+
+__attribute__((import_module("asyncify"), import_name("start_unwind"))) void
+asyncify_start_unwind(void *buf);
+#define asyncify_start_unwind(buf)                                             \
+  do {                                                                         \
+    extern void *rb_asyncify_unwind_buf;                                       \
+    rb_asyncify_unwind_buf = (buf);                                            \
+    asyncify_start_unwind((buf));                                              \
+  } while (0)
+__attribute__((import_module("asyncify"), import_name("stop_unwind"))) void
+asyncify_stop_unwind(void);
+#define asyncify_stop_unwind()                                                 \
+  do {                                                                         \
+    extern void *rb_asyncify_unwind_buf;                                       \
+    rb_asyncify_unwind_buf = NULL;                                             \
+    asyncify_stop_unwind();                                                    \
+  } while (0)
+__attribute__((import_module("asyncify"), import_name("start_rewind"))) void
+asyncify_start_rewind(void *buf);
+__attribute__((import_module("asyncify"), import_name("stop_rewind"))) void
+asyncify_stop_rewind(void);
+
+void *rb_wasm_handle_jmp_unwind(void);
+void *rb_wasm_handle_scan_unwind(void);
+void *rb_wasm_handle_fiber_unwind(void (**new_fiber_entry)(void *, void *),
+                                  void **arg0, void **arg1,
+                                  bool *is_new_fiber_started);
+#define RB_WASM_ENABLE_DEBUG_LOG 0
+
+#if RB_WASM_ENABLE_DEBUG_LOG
+#  define RB_WASM_DEBUG_LOG(...) fprintf(stderr, __VA_ARGS__)
+#else
+#  define RB_WASM_DEBUG_LOG(...) (void)0
+#endif
+
+static bool rb_should_prohibit_rewind = false;
+
+__attribute__((import_module("rb-js-abi-host"),
+               import_name("rb_wasm_throw_prohibit_rewind_exception")))
+__attribute__((noreturn)) void
+rb_wasm_throw_prohibit_rewind_exception(const char *c_msg, size_t msg_len);
+
+#define RB_WASM_CHECK_REWIND_PROHIBITED(msg)                                   \
+  /*                                                                           \
+    If the unwond source and rewinding destination are same, it's acceptable   \
+    to rewind even under nested VM operations.                                 \
+   */                                                                          \
+  if (rb_should_prohibit_rewind &&                                             \
+      (asyncify_buf != asyncify_unwound_buf || fiber_entry_point)) {           \
+    rb_wasm_throw_prohibit_rewind_exception(msg, sizeof(msg) - 1);             \
+  }
+
+#define RB_WASM_LIB_RT(MAIN_ENTRY)                                             \
+  {                                                                            \
+                                                                               \
+    void *arg0 = NULL, *arg1 = NULL;                                           \
+    void (*fiber_entry_point)(void *, void *) = NULL;                          \
+                                                                               \
+    while (1) {                                                                \
+      if (fiber_entry_point) {                                                 \
+        fiber_entry_point(arg0, arg1);                                         \
+      } else {                                                                 \
+        MAIN_ENTRY;                                                            \
+      }                                                                        \
+                                                                               \
+      bool new_fiber_started = false;                                          \
+      void *asyncify_buf = NULL;                                               \
+      extern void *rb_asyncify_unwind_buf;                                     \
+      void *asyncify_unwound_buf = rb_asyncify_unwind_buf;                     \
+      if (asyncify_unwound_buf == NULL)                                        \
+        break;                                                                 \
+      asyncify_stop_unwind();                                                  \
+                                                                               \
+      if ((asyncify_buf = rb_wasm_handle_jmp_unwind()) != NULL) {              \
+        RB_WASM_CHECK_REWIND_PROHIBITED("rb_wasm_handle_jmp_unwind")           \
+        asyncify_start_rewind(asyncify_buf);                                   \
+        continue;                                                              \
+      }                                                                        \
+      if ((asyncify_buf = rb_wasm_handle_scan_unwind()) != NULL) {             \
+        RB_WASM_CHECK_REWIND_PROHIBITED("rb_wasm_handle_scan_unwind")          \
+        asyncify_start_rewind(asyncify_buf);                                   \
+        continue;                                                              \
+      }                                                                        \
+                                                                               \
+      asyncify_buf = rb_wasm_handle_fiber_unwind(&fiber_entry_point, &arg0,    \
+                                                 &arg1, &new_fiber_started);   \
+      if (asyncify_buf) {                                                      \
+        RB_WASM_CHECK_REWIND_PROHIBITED("rb_wasm_handle_fiber_unwind")         \
+        asyncify_start_rewind(asyncify_buf);                                   \
+        continue;                                                              \
+      } else if (new_fiber_started) {                                          \
+        RB_WASM_CHECK_REWIND_PROHIBITED(                                       \
+            "rb_wasm_handle_fiber_unwind but new fiber");                      \
+        continue;                                                              \
+      }                                                                        \
+                                                                               \
+      break;                                                                   \
+    }                                                                          \
+  }
+
+#define c_strings_from_abi(list, new_args)                                     \
+  {                                                                            \
+    new_args = alloca(sizeof(char *) * ((list)->len + 1));                     \
+    for (size_t i = 0; i < (list)->len; i++) {                                 \
+      new_args[i] = (list)->ptr[i].ptr;                                        \
+    }                                                                          \
+  }
+
+static VALUE rb_abi_guest_arena_hash;
+static VALUE rb_abi_guest_refcount_hash;
+
+static VALUE rb_abi_lend_object_internal(VALUE obj) {
+  VALUE object_id = rb_obj_id(obj);
+  VALUE ref_count = rb_hash_lookup(rb_abi_guest_refcount_hash, object_id);
+  if (NIL_P(ref_count)) {
+    rb_hash_aset(rb_abi_guest_arena_hash, object_id, obj);
+    rb_hash_aset(rb_abi_guest_refcount_hash, object_id, INT2FIX(1));
+  } else {
+    rb_hash_aset(rb_abi_guest_refcount_hash, object_id,
+                 INT2FIX(FIX2INT(ref_count) + 1));
+  }
+  return Qundef;
+}
+void rb_abi_lend_object(VALUE obj) {
+  RB_WASM_DEBUG_LOG("rb_abi_lend_object: obj = %p\n", (void *)obj);
+  int state;
+  RB_WASM_LIB_RT(rb_protect(rb_abi_lend_object_internal, obj, &state));
+  assert(state == TAG_NONE && "rb_abi_lend_object_internal failed");
+}
+
+static VALUE rb_abi_guest_rb_abi_value_dtor_internal(VALUE obj) {
+  VALUE object_id = rb_obj_id(obj);
+  VALUE ref_count = rb_hash_lookup(rb_abi_guest_refcount_hash, object_id);
+  if (NIL_P(ref_count)) {
+    rb_warning("rb_abi_guest_rb_abi_value_dtor: double free detected");
+    return Qundef;
+  }
+  if (ref_count == INT2FIX(1)) {
+    RB_WASM_DEBUG_LOG("rb_abi_guest_rb_abi_value_dtor: ref_count == 1\n");
+    rb_hash_delete(rb_abi_guest_refcount_hash, object_id);
+    rb_hash_delete(rb_abi_guest_arena_hash, object_id);
+  } else {
+    RB_WASM_DEBUG_LOG("rb_abi_guest_rb_abi_value_dtor: ref_count = %d\n",
+                      FIX2INT(ref_count));
+    rb_hash_aset(rb_abi_guest_refcount_hash, object_id,
+                 INT2FIX(FIX2INT(ref_count) - 1));
+  }
+  return Qundef;
+}
+
+void rb_abi_guest_rb_abi_value_dtor(void *data) {
+  RB_WASM_DEBUG_LOG("rb_abi_guest_rb_abi_value_dtor: data = %p\n", data);
+  int state;
+  RB_WASM_LIB_RT(
+      rb_protect(rb_abi_guest_rb_abi_value_dtor_internal, (VALUE)data, &state));
+  assert(state == TAG_NONE && "rb_abi_guest_rb_abi_value_dtor_internal failed");
+}
+
+// MARK: - Exported functions
+// NOTE: Assume that callers always pass null terminated string by
+// rb_abi_guest_string_t
+
+void rb_abi_guest_ruby_show_version(void) { ruby_show_version(); }
+
+void rb_abi_guest_ruby_init(void) {
+  RB_WASM_LIB_RT(ruby_init())
+
+  rb_abi_guest_arena_hash = rb_hash_new();
+  rb_abi_guest_refcount_hash = rb_hash_new();
+
+  rb_gc_register_mark_object(rb_abi_guest_arena_hash);
+  rb_gc_register_mark_object(rb_abi_guest_refcount_hash);
+}
+
+void rb_abi_guest_ruby_sysinit(rb_abi_guest_list_string_t *args) {
+  char **c_args;
+  int argc = args->len;
+  c_strings_from_abi(args, c_args);
+  RB_WASM_LIB_RT(ruby_sysinit(&argc, &c_args))
+}
+
+rb_abi_guest_rb_iseq_t
+rb_abi_guest_ruby_options(rb_abi_guest_list_string_t *args) {
+  void *result;
+  char **c_args;
+  c_strings_from_abi(args, c_args);
+  RB_WASM_LIB_RT(result = ruby_options(args->len, c_args))
+  return rb_abi_guest_rb_iseq_new(result);
+}
+
+void rb_abi_guest_ruby_script(rb_abi_guest_string_t *name) {
+  RB_WASM_LIB_RT(ruby_script(name->ptr))
+}
+
+void rb_abi_guest_ruby_init_loadpath(void) {
+  RB_WASM_LIB_RT(ruby_init_loadpath())
+}
+
+void rb_abi_guest_rb_eval_string_protect(
+    rb_abi_guest_string_t *str, rb_abi_guest_tuple2_rb_abi_value_s32_t *ret0) {
+  VALUE retval;
+  RB_WASM_DEBUG_LOG("rb_eval_string_protect: str = %s\n", str->ptr);
+  VALUE utf8_str = rb_utf8_str_new(str->ptr, str->len);
+  RB_WASM_LIB_RT(retval = rb_eval_string_value_protect(utf8_str, &ret0->f1));
+  RB_WASM_DEBUG_LOG("rb_eval_string_protect: retval = %p, state = %d\n",
+                    (void *)retval, ret0->f1);
+
+  if (ret0->f1 == TAG_NONE) {
+    rb_abi_lend_object(retval);
+  }
+  ret0->f0 = rb_abi_guest_rb_abi_value_new((void *)retval);
+}
+
+struct rb_funcallv_thunk_ctx {
+  VALUE recv;
+  ID mid;
+  rb_abi_guest_list_rb_abi_value_t *args;
+};
+
+VALUE rb_funcallv_thunk(VALUE arg) {
+  struct rb_funcallv_thunk_ctx *ctx = (struct rb_funcallv_thunk_ctx *)arg;
+  VALUE *c_argv = alloca(sizeof(VALUE) * ctx->args->len);
+  for (size_t i = 0; i < ctx->args->len; i++) {
+    c_argv[i] = (VALUE)rb_abi_guest_rb_abi_value_get(&ctx->args->ptr[i]);
+  }
+  return rb_funcallv(ctx->recv, ctx->mid, ctx->args->len, c_argv);
+}
+
+void rb_abi_guest_rb_funcallv_protect(
+    rb_abi_guest_rb_abi_value_t recv, rb_abi_guest_rb_id_t mid,
+    rb_abi_guest_list_rb_abi_value_t *args,
+    rb_abi_guest_tuple2_rb_abi_value_s32_t *ret0) {
+  VALUE retval;
+  VALUE r_recv = (VALUE)rb_abi_guest_rb_abi_value_get(&recv);
+  struct rb_funcallv_thunk_ctx ctx = {.recv = r_recv, .mid = mid, .args = args};
+  RB_WASM_LIB_RT(retval =
+                     rb_protect(rb_funcallv_thunk, (VALUE)&ctx, &ret0->f1));
+  RB_WASM_DEBUG_LOG(
+      "rb_abi_guest_rb_funcallv_protect: retval = %p, state = %d\n",
+      (void *)retval, ret0->f1);
+
+  if (ret0->f1 == TAG_NONE) {
+    rb_abi_lend_object(retval);
+  }
+  ret0->f0 = rb_abi_guest_rb_abi_value_new((void *)retval);
+}
+
+rb_abi_guest_rb_id_t rb_abi_guest_rb_intern(rb_abi_guest_string_t *name) {
+  return rb_intern(name->ptr);
+}
+
+rb_abi_guest_rb_abi_value_t rb_abi_guest_rb_errinfo(void) {
+  VALUE retval;
+  RB_WASM_LIB_RT(retval = rb_errinfo());
+  rb_abi_lend_object(retval);
+  return rb_abi_guest_rb_abi_value_new((void *)retval);
+}
+
+void rb_abi_guest_rb_clear_errinfo(void) { rb_set_errinfo(Qnil); }
+
+void rb_abi_guest_rstring_ptr(rb_abi_guest_rb_abi_value_t value,
+                              rb_abi_guest_string_t *ret0) {
+  VALUE r_str = (VALUE)rb_abi_guest_rb_abi_value_get(&value);
+  ret0->len = RSTRING_LEN(r_str);
+  ret0->ptr = xmalloc(ret0->len);
+  memcpy(ret0->ptr, RSTRING_PTR(r_str), ret0->len);
+}
+
+uint32_t rb_abi_guest_rb_abi_value_data_ptr(rb_abi_guest_rb_abi_value_t self) {
+  VALUE obj = (VALUE)rb_abi_guest_rb_abi_value_get(&self);
+  return (uint32_t)DATA_PTR(obj);
+}
+
+_Static_assert(RUBY_API_VERSION_MAJOR == 3, "unsupported Ruby version");
+#if RUBY_API_VERSION_MINOR == 2
+void rb_vm_bugreport(const void *);
+
+void rb_abi_guest_rb_vm_bugreport(void) { rb_vm_bugreport(NULL); }
+#elif RUBY_API_VERSION_MINOR >= 3
+bool rb_vm_bugreport(const void *, FILE *);
+
+void rb_abi_guest_rb_vm_bugreport(void) { rb_vm_bugreport(NULL, stderr); }
+#else
+#  error "unsupported Ruby version"
+#endif
+
+bool rb_abi_guest_rb_gc_enable(void) { return rb_gc_enable() == Qtrue; }
+
+VALUE rb_gc_disable_no_rest(void);
+bool rb_abi_guest_rb_gc_disable(void) {
+  // NOTE: rb_gc_disable() is usually preferred to free up memory as much as
+  // possible before disabling GC. However it may trigger GC through gc_rest(),
+  // and triggering GC having a sandwitched JS frame is unsafe because it misses
+  // to mark some living objects in the frames behind the JS frame. So we use
+  // rb_gc_disable_no_rest(), which does not trigger GC, instead.
+  return rb_gc_disable_no_rest() == Qtrue;
+}
+
+bool rb_abi_guest_rb_set_should_prohibit_rewind(bool value) {
+  bool old = rb_should_prohibit_rewind;
+  rb_should_prohibit_rewind = value;
+  return old;
+}
+
+void Init_witapi(void) {}