debase-ruby_core_source 0.10.9 → 0.10.13

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview3 → ruby-3.1.0-preview1}/vm_core.h

@@ -1,3 +1,5 @@
+#ifndef RUBY_VM_CORE_H
+#define RUBY_VM_CORE_H
 /**********************************************************************
 
   vm_core.h -
@@ -9,9 +11,6 @@
 
 **********************************************************************/
 
-#ifndef RUBY_VM_CORE_H
-#define RUBY_VM_CORE_H
-
 /*
  * Enable check mode.
  *   1: enable local assertions.
@@ -46,6 +45,12 @@
 #define VMDEBUG 3
 #endif
 
+#include "ruby/internal/config.h"
+
+#include <stddef.h>
+#include <signal.h>
+#include <stdarg.h>
+
 #include "ruby_assert.h"
 
 #if VM_CHECK_MODE > 0
@@ -57,6 +62,26 @@
 #define VM_UNREACHABLE(func) UNREACHABLE
 #endif
 
+#include <setjmp.h>
+
+#include "ruby/internal/stdbool.h"
+#include "ccan/list/list.h"
+#include "id.h"
+#include "internal.h"
+#include "internal/array.h"
+#include "internal/serial.h"
+#include "internal/vm.h"
+#include "method.h"
+#include "node.h"
+#include "ruby/ruby.h"
+#include "ruby/st.h"
+#include "ruby_atomic.h"
+#include "vm_opts.h"
+#include "darray.h"
+
+#include "ruby/thread_native.h"
+#include THREAD_IMPL_H
+
 #define RUBY_VM_THREAD_MODEL 2
 
 /*
@@ -69,26 +94,6 @@
 # define VM_INSN_INFO_TABLE_IMPL 2
 #endif
 
-#include "ruby/ruby.h"
-#include "ruby/st.h"
-
-#include "node.h"
-#include "vm_opts.h"
-#include "id.h"
-#include "method.h"
-#include "ruby_atomic.h"
-#include "ccan/list/list.h"
-
-#include "ruby/thread_native.h"
-#if   defined(_WIN32)
-#include "thread_win32.h"
-#elif defined(HAVE_PTHREAD_H)
-#include "thread_pthread.h"
-#endif
-
-#include <setjmp.h>
-#include <signal.h>
-
 #if defined(NSIG_MAX)           /* POSIX issue 8 */
 # undef NSIG
 # define NSIG NSIG_MAX
@@ -123,22 +128,15 @@
 /* define to 0 to test old code path */
 #define WAITPID_USE_SIGCHLD (RUBY_SIGCHLD || SIGCHLD_LOSSY)
 
-#ifdef HAVE_STDARG_PROTOTYPES
-#include <stdarg.h>
-#define va_init_list(a,b) va_start((a),(b))
-#else
-#include <varargs.h>
-#define va_init_list(a,b) va_start((a))
-#endif
-
 #if defined(SIGSEGV) && defined(HAVE_SIGALTSTACK) && defined(SA_SIGINFO) && !defined(__NetBSD__)
 #  define USE_SIGALTSTACK
-void *rb_register_sigaltstack(void);
-#  define RB_ALTSTACK_INIT(var) var = rb_register_sigaltstack()
-#  define RB_ALTSTACK_FREE(var) xfree(var)
+void *rb_allocate_sigaltstack(void);
+void *rb_register_sigaltstack(void *);
+#  define RB_ALTSTACK_INIT(var, altstack) var = rb_register_sigaltstack(altstack)
+#  define RB_ALTSTACK_FREE(var) free(var)
 #  define RB_ALTSTACK(var)  var
 #else /* noop */
-#  define RB_ALTSTACK_INIT(var)
+#  define RB_ALTSTACK_INIT(var, altstack)
 #  define RB_ALTSTACK_FREE(var)
 #  define RB_ALTSTACK(var) (0)
 #endif
@@ -182,28 +180,28 @@ typedef unsigned long rb_num_t;
 typedef   signed long rb_snum_t;
 
 enum ruby_tag_type {
-    RUBY_TAG_NONE  = 0x0,
-    RUBY_TAG_RETURN    = 0x1,
-    RUBY_TAG_BREAK = 0x2,
-    RUBY_TAG_NEXT  = 0x3,
-    RUBY_TAG_RETRY = 0x4,
-    RUBY_TAG_REDO  = 0x5,
-    RUBY_TAG_RAISE = 0x6,
-    RUBY_TAG_THROW = 0x7,
-    RUBY_TAG_FATAL = 0x8,
-    RUBY_TAG_MASK  = 0xf
+    RUBY_TAG_NONE	= 0x0,
+    RUBY_TAG_RETURN	= 0x1,
+    RUBY_TAG_BREAK	= 0x2,
+    RUBY_TAG_NEXT	= 0x3,
+    RUBY_TAG_RETRY	= 0x4,
+    RUBY_TAG_REDO	= 0x5,
+    RUBY_TAG_RAISE	= 0x6,
+    RUBY_TAG_THROW	= 0x7,
+    RUBY_TAG_FATAL	= 0x8,
+    RUBY_TAG_MASK	= 0xf
 };
 
-#define TAG_NONE   RUBY_TAG_NONE
-#define TAG_RETURN RUBY_TAG_RETURN
-#define TAG_BREAK  RUBY_TAG_BREAK
-#define TAG_NEXT   RUBY_TAG_NEXT
-#define TAG_RETRY  RUBY_TAG_RETRY
-#define TAG_REDO   RUBY_TAG_REDO
-#define TAG_RAISE  RUBY_TAG_RAISE
-#define TAG_THROW  RUBY_TAG_THROW
-#define TAG_FATAL  RUBY_TAG_FATAL
-#define TAG_MASK   RUBY_TAG_MASK
+#define TAG_NONE	RUBY_TAG_NONE
+#define TAG_RETURN	RUBY_TAG_RETURN
+#define TAG_BREAK	RUBY_TAG_BREAK
+#define TAG_NEXT	RUBY_TAG_NEXT
+#define TAG_RETRY	RUBY_TAG_RETRY
+#define TAG_REDO	RUBY_TAG_REDO
+#define TAG_RAISE	RUBY_TAG_RAISE
+#define TAG_THROW	RUBY_TAG_THROW
+#define TAG_FATAL	RUBY_TAG_FATAL
+#define TAG_MASK	RUBY_TAG_MASK
 
 enum ruby_vm_throw_flags {
     VM_THROW_NO_ESCAPE_FLAG = 0x8000,
@@ -217,47 +215,88 @@ struct rb_control_frame_struct;
 /* iseq data type */
 typedef struct rb_compile_option_struct rb_compile_option_t;
 
-struct iseq_inline_cache_entry {
-    rb_serial_t ic_serial;
-    const rb_cref_t *ic_cref;
-    union {
-   size_t index;
-   VALUE value;
-    } ic_value;
+union ic_serial_entry {
+    rb_serial_t raw;
+    VALUE data[2];
 };
 
-union iseq_inline_storage_entry {
-    struct {
-   struct rb_thread_struct *running_thread;
-   VALUE value;
-    } once;
-    struct iseq_inline_cache_entry cache;
+// imemo_constcache
+struct iseq_inline_constant_cache_entry {
+    VALUE flags;
+
+    VALUE value;              // v0
+    union ic_serial_entry ic_serial; // v1, v2
+    const rb_cref_t *ic_cref; // v3
+};
+STATIC_ASSERT(sizeof_iseq_inline_constant_cache_entry,
+              (offsetof(struct iseq_inline_constant_cache_entry, ic_cref) +
+	       sizeof(const rb_cref_t *)) <= sizeof(struct RObject));
+
+#if SIZEOF_SERIAL_T <= SIZEOF_VALUE
+
+#define GET_IC_SERIAL(ice) (ice)->ic_serial.raw
+#define SET_IC_SERIAL(ice, v) (ice)->ic_serial.raw = (v)
+
+#else
+
+static inline rb_serial_t
+get_ic_serial(const struct iseq_inline_constant_cache_entry *ice)
+{
+    union ic_serial_entry tmp;
+    tmp.data[0] = ice->ic_serial.data[0];
+    tmp.data[1] = ice->ic_serial.data[1];
+    return tmp.raw;
+}
+
+#define GET_IC_SERIAL(ice) get_ic_serial(ice)
+
+static inline void
+set_ic_serial(struct iseq_inline_constant_cache_entry *ice, rb_serial_t v)
+{
+    union ic_serial_entry tmp;
+    tmp.raw = v;
+    ice->ic_serial.data[0] = tmp.data[0];
+    ice->ic_serial.data[1] = tmp.data[1];
+}
+
+#define SET_IC_SERIAL(ice, v) set_ic_serial((ice), (v))
+
+#endif
+
+struct iseq_inline_constant_cache {
+    struct iseq_inline_constant_cache_entry *entry;
+    // For YJIT: the index to the opt_getinlinecache instruction in the same iseq.
+    // It's set during compile time and constant once set.
+    unsigned get_insn_idx;
+};
+
+struct iseq_inline_iv_cache_entry {
+    struct rb_iv_index_tbl_entry *entry;
 };
 
-struct rb_call_info_kw_arg {
-    int keyword_len;
-    VALUE keywords[1];
+struct iseq_inline_cvar_cache_entry {
+    struct rb_cvar_class_tbl_entry *entry;
 };
 
-struct rb_call_info_with_kwarg {
-    struct rb_call_info ci;
-    struct rb_call_info_kw_arg *kw_arg;
+union iseq_inline_storage_entry {
+    struct {
+	struct rb_thread_struct *running_thread;
+	VALUE value;
+    } once;
+    struct iseq_inline_constant_cache ic_cache;
+    struct iseq_inline_iv_cache_entry iv_cache;
 };
 
 struct rb_calling_info {
+    const struct rb_callinfo *ci;
+    const struct rb_callcache *cc;
     VALUE block_handler;
     VALUE recv;
     int argc;
     int kw_splat;
 };
 
-struct rb_kwarg_call_data {
-    struct rb_call_cache cc;
-    struct rb_call_info_with_kwarg ci_kw;
-};
-
 struct rb_execution_context_struct;
-typedef VALUE (*vm_call_handler)(struct rb_execution_context_struct *ec, struct rb_control_frame_struct *cfp, struct rb_calling_info *calling, struct rb_call_data *cd);
 
 #if 1
 #define CoreDataFromValue(obj, type) (type*)DATA_PTR(obj)
@@ -282,11 +321,11 @@ static inline VALUE
 pathobj_path(VALUE pathobj)
 {
     if (RB_TYPE_P(pathobj, T_STRING)) {
-   return pathobj;
+	return pathobj;
     }
     else {
-   VM_ASSERT(RB_TYPE_P(pathobj, T_ARRAY));
-   return RARRAY_AREF(pathobj, PATHOBJ_PATH);
+	VM_ASSERT(RB_TYPE_P(pathobj, T_ARRAY));
+	return RARRAY_AREF(pathobj, PATHOBJ_PATH);
     }
 }
 
@@ -294,28 +333,32 @@ static inline VALUE
 pathobj_realpath(VALUE pathobj)
 {
     if (RB_TYPE_P(pathobj, T_STRING)) {
-   return pathobj;
+	return pathobj;
     }
     else {
-   VM_ASSERT(RB_TYPE_P(pathobj, T_ARRAY));
-   return RARRAY_AREF(pathobj, PATHOBJ_REALPATH);
+	VM_ASSERT(RB_TYPE_P(pathobj, T_ARRAY));
+	return RARRAY_AREF(pathobj, PATHOBJ_REALPATH);
     }
 }
 
 /* Forward declarations */
 struct rb_mjit_unit;
 
+// List of YJIT block versions
+typedef rb_darray(struct yjit_block_version *) rb_yjit_block_array_t;
+typedef rb_darray(rb_yjit_block_array_t) rb_yjit_block_array_array_t;
+
 struct rb_iseq_constant_body {
     enum iseq_type {
-   ISEQ_TYPE_TOP,
-   ISEQ_TYPE_METHOD,
-   ISEQ_TYPE_BLOCK,
-   ISEQ_TYPE_CLASS,
-   ISEQ_TYPE_RESCUE,
-   ISEQ_TYPE_ENSURE,
-   ISEQ_TYPE_EVAL,
-   ISEQ_TYPE_MAIN,
-   ISEQ_TYPE_PLAIN
+	ISEQ_TYPE_TOP,
+	ISEQ_TYPE_METHOD,
+	ISEQ_TYPE_BLOCK,
+	ISEQ_TYPE_CLASS,
+	ISEQ_TYPE_RESCUE,
+	ISEQ_TYPE_ENSURE,
+	ISEQ_TYPE_EVAL,
+	ISEQ_TYPE_MAIN,
+	ISEQ_TYPE_PLAIN
     } type;              /* instruction sequence type */
 
     unsigned int iseq_size;
@@ -345,67 +388,67 @@ struct rb_iseq_constant_body {
      */
 
     struct {
-   struct {
-       unsigned int has_lead   : 1;
-       unsigned int has_opt    : 1;
-       unsigned int has_rest   : 1;
-       unsigned int has_post   : 1;
-       unsigned int has_kw     : 1;
-       unsigned int has_kwrest : 1;
-       unsigned int has_block  : 1;
-
-       unsigned int ambiguous_param0 : 1; /* {|a|} */
-       unsigned int accepts_no_kwarg : 1;
+	struct {
+	    unsigned int has_lead   : 1;
+	    unsigned int has_opt    : 1;
+	    unsigned int has_rest   : 1;
+	    unsigned int has_post   : 1;
+	    unsigned int has_kw     : 1;
+	    unsigned int has_kwrest : 1;
+	    unsigned int has_block  : 1;
+
+	    unsigned int ambiguous_param0 : 1; /* {|a|} */
+	    unsigned int accepts_no_kwarg : 1;
             unsigned int ruby2_keywords: 1;
-   } flags;
-
-   unsigned int size;
-
-   int lead_num;
-   int opt_num;
-   int rest_start;
-   int post_start;
-   int post_num;
-   int block_start;
-
-   const VALUE *opt_table; /* (opt_num + 1) entries. */
-   /* opt_num and opt_table:
-    *
-    * def foo o1=e1, o2=e2, ..., oN=eN
-    * #=>
-    *   # prologue code
-    *   A1: e1
-    *   A2: e2
-    *   ...
-    *   AN: eN
-    *   AL: body
-    * opt_num = N
-    * opt_table = [A1, A2, ..., AN, AL]
-    */
-
-   const struct rb_iseq_param_keyword {
-       int num;
-       int required_num;
-       int bits_start;
-       int rest_start;
-       const ID *table;
+	} flags;
+
+	unsigned int size;
+
+	int lead_num;
+	int opt_num;
+	int rest_start;
+	int post_start;
+	int post_num;
+	int block_start;
+
+	const VALUE *opt_table; /* (opt_num + 1) entries. */
+	/* opt_num and opt_table:
+	 *
+	 * def foo o1=e1, o2=e2, ..., oN=eN
+	 * #=>
+	 *   # prologue code
+	 *   A1: e1
+	 *   A2: e2
+	 *   ...
+	 *   AN: eN
+	 *   AL: body
+	 * opt_num = N
+	 * opt_table = [A1, A2, ..., AN, AL]
+	 */
+
+	const struct rb_iseq_param_keyword {
+	    int num;
+	    int required_num;
+	    int bits_start;
+	    int rest_start;
+	    const ID *table;
             VALUE *default_values;
-   } *keyword;
+	} *keyword;
     } param;
 
     rb_iseq_location_t location;
 
     /* insn info, must be freed */
     struct iseq_insn_info {
-   const struct iseq_insn_info_entry *body;
-   unsigned int *positions;
-   unsigned int size;
+	const struct iseq_insn_info_entry *body;
+	unsigned int *positions;
+	unsigned int size;
 #if VM_INSN_INFO_TABLE_IMPL == 2
-   struct succ_index_table *succ_index_table;
+	struct succ_index_table *succ_index_table;
 #endif
     } insns_info;
 
-    const ID *local_table;     /* must free */
+    const ID *local_table;		/* must free */
 
     /* catch table */
     struct iseq_catch_table *catch_table;
@@ -415,27 +458,29 @@ struct rb_iseq_constant_body {
     struct rb_iseq_struct *local_iseq; /* local_iseq->flip_cnt can be modified */
 
     union iseq_inline_storage_entry *is_entries;
-    struct rb_call_data *call_data; /* A buffer for two arrays:
-                                     * struct rb_call_data calls[ci_size];
-                                     * struct rb_kwarg_call_data kw_calls[ci_kw_size];
-                                     * Such that:
-                                     * struct rb_kwarg_call_data *kw_calls = &body->call_data[ci_size];
-                                     */
+    struct rb_call_data *call_data; //struct rb_call_data calls[ci_size];
 
     struct {
-   rb_snum_t flip_count;
-   VALUE coverage;
+	rb_snum_t flip_count;
+        VALUE script_lines;
+	VALUE coverage;
         VALUE pc2branchindex;
-   VALUE *original_iseq;
+	VALUE *original_iseq;
     } variable;
 
     unsigned int local_table_size;
     unsigned int is_size;
     unsigned int ci_size;
-    unsigned int ci_kw_size;
     unsigned int stack_max; /* for stack overflow check */
 
     char catch_except_p; /* If a frame of this ISeq may catch exception, set TRUE */
+    // If true, this ISeq is leaf *and* backtraces are not used, for example,
+    // by rb_profile_frames. We verify only leafness on VM_CHECK_MODE though.
+    // Note that GC allocations might use backtraces due to
+    // ObjectSpace#trace_object_allocations.
+    // For more details, see: https://bugs.ruby-lang.org/issues/16956
+    bool builtin_inline_p;
+    struct rb_id_table *outer_variables;
 
 #if USE_MJIT
     /* The following fields are MJIT related info.  */
@@ -444,6 +489,8 @@ struct rb_iseq_constant_body {
     long unsigned total_calls; /* number of total calls with `mjit_exec()` */
     struct rb_mjit_unit *jit_unit;
 #endif
+
+    rb_yjit_block_array_array_t yjit_blocks; // empty, or has a size equal to iseq_size
 };
 
 /* T_IMEMO/iseq */
@@ -455,12 +502,12 @@ struct rb_iseq_struct {
     struct rb_iseq_constant_body *body;  /* 3 */
 
     union { /* 4, 5 words */
-   struct iseq_compile_data *compile_data; /* used at compile time */
+	struct iseq_compile_data *compile_data; /* used at compile time */
 
-   struct {
-       VALUE obj;
-       int index;
-   } loader;
+	struct {
+	    VALUE obj;
+	    int index;
+	} loader;
 
         struct {
             struct rb_hook_list_struct *local_hooks;
@@ -482,7 +529,7 @@ rb_iseq_check(const rb_iseq_t *iseq)
 {
 #if USE_LAZY_LOAD
     if (iseq->body == NULL) {
-   rb_iseq_complete((rb_iseq_t *)iseq);
+	rb_iseq_complete((rb_iseq_t *)iseq);
     }
 #endif
     return iseq;
@@ -492,7 +539,7 @@ static inline const rb_iseq_t *
 def_iseq_ptr(rb_method_definition_t *def)
 {
 //TODO: re-visit. to check the bug, enable this assertion.
-#if 1 || VM_CHECK_MODE > 0
+#if VM_CHECK_MODE > 0
     if (def->type != VM_METHOD_TYPE_ISEQ) rb_bug("def_iseq_ptr: not iseq (%d)", def->type);
 #endif
     return rb_iseq_check(def->body.iseq.iseqptr);
@@ -571,12 +618,30 @@ typedef const struct rb_builtin_function *RB_BUILTIN;
 typedef struct rb_vm_struct {
     VALUE self;
 
-    rb_global_vm_lock_t gvl;
+    struct {
+        struct list_head set;
+        unsigned int cnt;
+        unsigned int blocking_cnt;
 
-    struct rb_thread_struct *main_thread;
+        struct rb_ractor_struct *main_ractor;
+        struct rb_thread_struct *main_thread; // == vm->ractor.main_ractor->threads.main
 
-    /* persists across uncontended GVL release/acquire for time slice */
-    const struct rb_thread_struct *running_thread;
+        struct {
+            // monitor
+            rb_nativethread_lock_t lock;
+            struct rb_ractor_struct *lock_owner;
+            unsigned int lock_rec;
+
+            // barrier
+            bool barrier_waiting;
+            unsigned int barrier_cnt;
+            rb_nativethread_cond_t barrier_cond;
+
+            // join at exit
+            rb_nativethread_cond_t terminate_cond;
+            bool terminate_waiting;
+        } sync;
+    } ractor;
 
 #ifdef USE_SIGALTSTACK
     void *main_altstack;
@@ -587,9 +652,6 @@ typedef struct rb_vm_struct {
     struct list_head waiting_pids; /* PID > 0: <=> struct waitpid_state */
     struct list_head waiting_grps; /* PID <= 0: <=> struct waitpid_state */
     struct list_head waiting_fds; /* <=> struct waiting_fd */
-    struct list_head living_threads;
-    VALUE thgroup_default;
-    int living_thread_num;
 
     /* set in single-threaded processes only: */
     volatile int ubf_async_safe;
@@ -597,9 +659,7 @@ typedef struct rb_vm_struct {
     unsigned int running: 1;
     unsigned int thread_abort_on_exception: 1;
     unsigned int thread_report_on_exception: 1;
-
-    unsigned int safe_level_: 1;
-    int sleeper;
+    unsigned int thread_ignore_deadlock: 1;
 
     /* object management */
     VALUE mark_object_ary;
@@ -613,23 +673,21 @@ typedef struct rb_vm_struct {
     VALUE expanded_load_path;
     VALUE loaded_features;
     VALUE loaded_features_snapshot;
+    VALUE loaded_features_realpaths;
     struct st_table *loaded_features_index;
     struct st_table *loading_table;
 
     /* signal */
     struct {
-   VALUE cmd[RUBY_NSIG];
+	VALUE cmd[RUBY_NSIG];
     } trap_list;
 
-    /* hook */
-    rb_hook_list_t global_hooks;
-
     /* relation table of ensure - rollback for callcc */
     struct st_table *ensure_rollback_table;
 
     /* postponed_job (async-signal-safe, NOT thread-safe) */
     struct rb_postponed_job_struct *postponed_job_buffer;
-    int postponed_job_index;
+    rb_atomic_t postponed_job_index;
 
     int src_encoding_index;
 
@@ -637,8 +695,8 @@ typedef struct rb_vm_struct {
     struct list_head workqueue; /* <=> rb_workqueue_job.jnode */
     rb_nativethread_lock_t workqueue_lock;
 
-    VALUE verbose, debug, orig_progname, progname;
-    VALUE coverages;
+    VALUE orig_progname, progname;
+    VALUE coverages, me2counter;
     int coverage_mode;
 
     st_table * defined_module_hash;
@@ -647,18 +705,28 @@ typedef struct rb_vm_struct {
 
     rb_at_exit_list *at_exit;
 
-    VALUE *defined_strings;
     st_table *frozen_strings;
 
     const struct rb_builtin_function *builtin_function_table;
     int builtin_inline_index;
 
+    struct rb_id_table *negative_cme_table;
+
+#ifndef VM_GLOBAL_CC_CACHE_TABLE_SIZE
+#define VM_GLOBAL_CC_CACHE_TABLE_SIZE 1023
+#endif
+    const struct rb_callcache *global_cc_cache_table[VM_GLOBAL_CC_CACHE_TABLE_SIZE]; // vm_eval.c
+
+#if defined(USE_VM_CLOCK) && USE_VM_CLOCK
+    uint32_t clock;
+#endif
+
     /* params */
     struct { /* size in byte */
-   size_t thread_vm_stack_size;
-   size_t thread_machine_stack_size;
-   size_t fiber_vm_stack_size;
-   size_t fiber_machine_stack_size;
+	size_t thread_vm_stack_size;
+	size_t thread_machine_stack_size;
+	size_t fiber_vm_stack_size;
+	size_t fiber_machine_stack_size;
     } default_params;
 
     short redefined_flag[BOP_LAST_];
@@ -723,9 +791,9 @@ struct rb_captured_block {
     VALUE self;
     const VALUE *ep;
     union {
-   const rb_iseq_t *iseq;
-   const struct vm_ifunc *ifunc;
-   VALUE val;
+	const rb_iseq_t *iseq;
+	const struct vm_ifunc *ifunc;
+	VALUE val;
     } code;
 };
 
@@ -745,25 +813,27 @@ enum rb_block_type {
 
 struct rb_block {
     union {
-   struct rb_captured_block captured;
-   VALUE symbol;
-   VALUE proc;
+	struct rb_captured_block captured;
+	VALUE symbol;
+	VALUE proc;
     } as;
     enum rb_block_type type;
 };
 
 typedef struct rb_control_frame_struct {
-    const VALUE *pc;       /* cfp[0] */
-    VALUE *sp;         /* cfp[1] */
-    const rb_iseq_t *iseq; /* cfp[2] */
-    VALUE self;            /* cfp[3] / block[0] */
-    const VALUE *ep;       /* cfp[4] / block[1] */
-    const void *block_code;     /* cfp[5] / block[2] */ /* iseq or ifunc */
+    const VALUE *pc;		/* cfp[0] */
+    VALUE *sp;			/* cfp[1] */
+    const rb_iseq_t *iseq;	/* cfp[2] */
+    VALUE self;			/* cfp[3] / block[0] */
+    const VALUE *ep;		/* cfp[4] / block[1] */
+    const void *block_code;     /* cfp[5] / block[2] */ /* iseq or ifunc or forwarded block handler */
     VALUE *__bp__;              /* cfp[6] */ /* outside vm_push_frame, use vm_base_ptr instead. */
 
 #if VM_DEBUG_BP_CHECK
-    VALUE *bp_check;       /* cfp[7] */
+    VALUE *bp_check;		/* cfp[7] */
 #endif
+    // Return address for YJIT code
+    void *jit_return;
 } rb_control_frame_t;
 
 extern const rb_data_type_t ruby_threadptr_data_type;
@@ -797,16 +867,13 @@ struct rb_vm_tag {
     rb_jmpbuf_t buf;
     struct rb_vm_tag *prev;
     enum ruby_tag_type state;
+    unsigned int lock_rec;
 };
 
 STATIC_ASSERT(rb_vm_tag_buf_offset, offsetof(struct rb_vm_tag, buf) > 0);
 STATIC_ASSERT(rb_vm_tag_buf_end,
-         offsetof(struct rb_vm_tag, buf) + sizeof(rb_jmpbuf_t) <
-         sizeof(struct rb_vm_tag));
-
-struct rb_vm_protect_tag {
-    struct rb_vm_protect_tag *prev;
-};
+	      offsetof(struct rb_vm_tag, buf) + sizeof(rb_jmpbuf_t) <
+	      sizeof(struct rb_vm_tag));
 
 struct rb_unblock_callback {
     rb_unblock_function_t *func;
@@ -815,11 +882,6 @@ struct rb_unblock_callback {
 
 struct rb_mutex_struct;
 
-typedef struct rb_thread_list_struct{
-    struct rb_thread_list_struct *next;
-    struct rb_thread_struct *th;
-} rb_thread_list_t;
-
 typedef struct rb_ensure_entry {
     VALUE marker;
     VALUE (*e_proc)(VALUE);
@@ -835,24 +897,32 @@ typedef char rb_thread_id_string_t[sizeof(rb_nativethread_id_t) * 2 + 3];
 
 typedef struct rb_fiber_struct rb_fiber_t;
 
-typedef struct rb_execution_context_struct {
+struct rb_waiting_list {
+    struct rb_waiting_list *next;
+    struct rb_thread_struct *thread;
+    struct rb_fiber_struct *fiber;
+};
+
+struct rb_execution_context_struct {
     /* execution information */
-    VALUE *vm_stack;       /* must free, must mark */
+    VALUE *vm_stack;		/* must free, must mark */
     size_t vm_stack_size;       /* size in word (byte size / sizeof(VALUE)) */
     rb_control_frame_t *cfp;
 
     struct rb_vm_tag *tag;
-    struct rb_vm_protect_tag *protect_tag;
 
     /* interrupt flags */
     rb_atomic_t interrupt_flag;
     rb_atomic_t interrupt_mask; /* size should match flag */
+#if defined(USE_VM_CLOCK) && USE_VM_CLOCK
+    uint32_t checked_clock;
+#endif
 
     rb_fiber_t *fiber_ptr;
     struct rb_thread_struct *thread_ptr;
 
     /* storage (ec (fiber) local) */
-    st_table *local_storage;
+    struct rb_id_table *local_storage;
     VALUE local_storage_recursive_hash;
     VALUE local_storage_recursive_hash_for_trace;
 
@@ -879,12 +949,17 @@ typedef struct rb_execution_context_struct {
 
     /* for GC */
     struct {
-   VALUE *stack_start;
-   VALUE *stack_end;
-   size_t stack_maxsize;
-   RUBY_ALIGNAS(SIZEOF_VALUE) jmp_buf regs;
+	VALUE *stack_start;
+	VALUE *stack_end;
+	size_t stack_maxsize;
+	RUBY_ALIGNAS(SIZEOF_VALUE) jmp_buf regs;
     } machine;
-} rb_execution_context_t;
+};
+
+#ifndef rb_execution_context_t
+typedef struct rb_execution_context_struct rb_execution_context_t;
+#define rb_execution_context_t rb_execution_context_t
+#endif
 
 // for builtin.h
 #define VM_CORE_H_EC_DEFINED 1
@@ -902,9 +977,20 @@ void rb_ec_initialize_vm_stack(rb_execution_context_t *ec, VALUE *stack, size_t
 // @param ec the execution context to update.
 void rb_ec_clear_vm_stack(rb_execution_context_t *ec);
 
+struct rb_ext_config {
+    bool ractor_safe;
+};
+
+typedef struct rb_ractor_struct rb_ractor_t;
+
+#if defined(__linux__) || defined(__FreeBSD__)
+# define RB_THREAD_T_HAS_NATIVE_ID
+#endif
+
 typedef struct rb_thread_struct {
-    struct list_node vmlt_node;
+    struct list_node lt_node; // managed by a ractor
     VALUE self;
+    rb_ractor_t *ractor;
     rb_vm_t *vm;
 
     rb_execution_context_t *ec;
@@ -922,6 +1008,9 @@ typedef struct rb_thread_struct {
     rb_nativethread_id_t thread_id;
 #ifdef NON_SCALAR_THREAD_ID
     rb_thread_id_string_t thread_id_string;
+#endif
+#ifdef RB_THREAD_T_HAS_NATIVE_ID
+    int tid;
 #endif
     BITFIELD(enum rb_thread_status, status, 2);
     /* bit flags */
@@ -953,7 +1042,7 @@ typedef struct rb_thread_struct {
     VALUE locking_mutex;
     struct rb_mutex_struct *keeping_mutexes;
 
-    rb_thread_list_t *join_list;
+    struct rb_waiting_list *join_list;
 
     union {
         struct {
@@ -967,9 +1056,10 @@ typedef struct rb_thread_struct {
         } func;
     } invoke_arg;
 
-    enum {
+    enum thread_invoke_type {
         thread_invoke_type_none = 0,
         thread_invoke_type_proc,
+        thread_invoke_type_ractor_proc,
         thread_invoke_type_func
     } invoke_type;
 
@@ -978,11 +1068,18 @@ typedef struct rb_thread_struct {
 
     /* fiber */
     rb_fiber_t *root_fiber;
-    rb_jmpbuf_t root_jmpbuf;
+
+    VALUE scheduler;
+    unsigned blocking;
 
     /* misc */
     VALUE name;
 
+    struct rb_ext_config ext_config;
+
+#ifdef USE_SIGALTSTACK
+    void *altstack;
+#endif
 } rb_thread_t;
 
 typedef enum {
@@ -1004,11 +1101,13 @@ typedef enum {
 RUBY_SYMBOL_EXPORT_BEGIN
 
 /* node -> iseq */
-rb_iseq_t *rb_iseq_new         (const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent, enum iseq_type);
-rb_iseq_t *rb_iseq_new_top     (const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent);
-rb_iseq_t *rb_iseq_new_main    (const rb_ast_body_t *ast,             VALUE path, VALUE realpath, const rb_iseq_t *parent);
-rb_iseq_t *rb_iseq_new_with_opt(const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno,
-               const rb_iseq_t *parent, enum iseq_type, const rb_compile_option_t*);
+rb_iseq_t *rb_iseq_new         (const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath,                     const rb_iseq_t *parent, enum iseq_type);
+rb_iseq_t *rb_iseq_new_top     (const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath,                     const rb_iseq_t *parent);
+rb_iseq_t *rb_iseq_new_main    (const rb_ast_body_t *ast,             VALUE path, VALUE realpath,                     const rb_iseq_t *parent);
+rb_iseq_t *rb_iseq_new_eval    (const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno, const rb_iseq_t *parent, int isolated_depth);
+rb_iseq_t *rb_iseq_new_with_opt(const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno, const rb_iseq_t *parent, int isolated_depth,
+                                enum iseq_type, const rb_compile_option_t*);
+
 struct iseq_link_anchor;
 struct rb_iseq_new_with_callback_callback_func {
     VALUE flags;
@@ -1043,10 +1142,17 @@ RUBY_SYMBOL_EXPORT_END
 
 typedef struct {
     const struct rb_block block;
-    unsigned int is_from_method: 1;    /* bool */
-    unsigned int is_lambda: 1;     /* bool */
+    unsigned int is_from_method: 1;	/* bool */
+    unsigned int is_lambda: 1;		/* bool */
+    unsigned int is_isolated: 1;        /* bool */
 } rb_proc_t;
 
+RUBY_SYMBOL_EXPORT_BEGIN
+VALUE rb_proc_isolate(VALUE self);
+VALUE rb_proc_isolate_bang(VALUE self);
+VALUE rb_proc_ractor_make_shareable(VALUE self);
+RUBY_SYMBOL_EXPORT_END
+
 typedef struct {
     VALUE flags; /* imemo header */
     rb_iseq_t *iseq;
@@ -1077,35 +1183,6 @@ enum vm_check_match_type {
 #define VM_CHECKMATCH_TYPE_MASK   0x03
 #define VM_CHECKMATCH_ARRAY       0x04
 
-enum vm_call_flag_bits {
-    VM_CALL_ARGS_SPLAT_bit,     /* m(*args) */
-    VM_CALL_ARGS_BLOCKARG_bit,  /* m(&block) */
-    VM_CALL_FCALL_bit,          /* m(...) */
-    VM_CALL_VCALL_bit,          /* m */
-    VM_CALL_ARGS_SIMPLE_bit,    /* (ci->flag & (SPLAT|BLOCKARG)) && blockiseq == NULL && ci->kw_arg == NULL */
-    VM_CALL_BLOCKISEQ_bit,      /* has blockiseq */
-    VM_CALL_KWARG_bit,          /* has kwarg */
-    VM_CALL_KW_SPLAT_bit,       /* m(**opts) */
-    VM_CALL_TAILCALL_bit,       /* located at tail position */
-    VM_CALL_SUPER_bit,          /* super */
-    VM_CALL_ZSUPER_bit,         /* zsuper */
-    VM_CALL_OPT_SEND_bit,       /* internal flag */
-    VM_CALL__END
-};
-
-#define VM_CALL_ARGS_SPLAT      (0x01 << VM_CALL_ARGS_SPLAT_bit)
-#define VM_CALL_ARGS_BLOCKARG   (0x01 << VM_CALL_ARGS_BLOCKARG_bit)
-#define VM_CALL_FCALL           (0x01 << VM_CALL_FCALL_bit)
-#define VM_CALL_VCALL           (0x01 << VM_CALL_VCALL_bit)
-#define VM_CALL_ARGS_SIMPLE     (0x01 << VM_CALL_ARGS_SIMPLE_bit)
-#define VM_CALL_BLOCKISEQ       (0x01 << VM_CALL_BLOCKISEQ_bit)
-#define VM_CALL_KWARG           (0x01 << VM_CALL_KWARG_bit)
-#define VM_CALL_KW_SPLAT        (0x01 << VM_CALL_KW_SPLAT_bit)
-#define VM_CALL_TAILCALL        (0x01 << VM_CALL_TAILCALL_bit)
-#define VM_CALL_SUPER           (0x01 << VM_CALL_SUPER_bit)
-#define VM_CALL_ZSUPER          (0x01 << VM_CALL_ZSUPER_bit)
-#define VM_CALL_OPT_SEND        (0x01 << VM_CALL_OPT_SEND_bit)
-
 enum vm_special_object_type {
     VM_SPECIAL_OBJECT_VMCORE = 1,
     VM_SPECIAL_OBJECT_CBASE,
@@ -1121,10 +1198,12 @@ enum vm_svar_index {
 };
 
 /* inline cache */
-typedef struct iseq_inline_cache_entry *IC;
+typedef struct iseq_inline_constant_cache *IC;
+typedef struct iseq_inline_iv_cache_entry *IVC;
+typedef struct iseq_inline_cvar_cache_entry *ICVARC;
 typedef union iseq_inline_storage_entry *ISE;
-typedef struct rb_call_info *CALL_INFO;
-typedef struct rb_call_cache *CALL_CACHE;
+typedef const struct rb_callinfo *CALL_INFO;
+typedef const struct rb_callcache *CALL_CACHE;
 typedef struct rb_call_data *CALL_DATA;
 
 typedef VALUE CDHASH;
@@ -1145,11 +1224,11 @@ typedef rb_control_frame_t *
 
 enum {
     /* Frame/Environment flag bits:
-     *   MMMM MMMM MMMM MMMM ____ FFFF FFFF EEEX (LSB)
+     *   MMMM MMMM MMMM MMMM ____ _FFF FFFF EEEX (LSB)
      *
      * X   : tag for GC marking (It seems as Fixnum)
      * EEE : 3 bits Env flags
-     * FF..: 8 bits Frame flags
+     * FF..: 7 bits Frame flags
      * MM..: 15 bits frame magic (to check frame corruption)
      */
 
@@ -1167,19 +1246,19 @@ enum {
     VM_FRAME_MAGIC_MASK   = 0x7fff0001,
 
     /* frame flag */
-    VM_FRAME_FLAG_PASSED    = 0x0010,
     VM_FRAME_FLAG_FINISH    = 0x0020,
     VM_FRAME_FLAG_BMETHOD   = 0x0040,
     VM_FRAME_FLAG_CFRAME    = 0x0080,
     VM_FRAME_FLAG_LAMBDA    = 0x0100,
     VM_FRAME_FLAG_MODIFIED_BLOCK_PARAM = 0x0200,
     VM_FRAME_FLAG_CFRAME_KW = 0x0400,
-    VM_FRAME_FLAG_CFRAME_EMPTY_KW = 0x0800, /* -- Remove In 3.0 -- */
+    VM_FRAME_FLAG_PASSED    = 0x0800,
 
     /* env flag */
     VM_ENV_FLAG_LOCAL       = 0x0002,
     VM_ENV_FLAG_ESCAPED     = 0x0004,
-    VM_ENV_FLAG_WB_REQUIRED = 0x0008
+    VM_ENV_FLAG_WB_REQUIRED = 0x0008,
+    VM_ENV_FLAG_ISOLATED    = 0x0010,
 };
 
 #define VM_ENV_DATA_SIZE             ( 3)
@@ -1235,13 +1314,6 @@ VM_FRAME_CFRAME_KW_P(const rb_control_frame_t *cfp)
     return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_CFRAME_KW) != 0;
 }
 
-/* -- Remove In 3.0 -- */
-static inline int
-VM_FRAME_CFRAME_EMPTY_KW_P(const rb_control_frame_t *cfp)
-{
-    return VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_CFRAME_EMPTY_KW) != 0;
-}
-
 static inline int
 VM_FRAME_FINISHED_P(const rb_control_frame_t *cfp)
 {
@@ -1324,6 +1396,7 @@ vm_assert_env(VALUE obj)
 }
 #endif
 
+RBIMPL_ATTR_NONNULL((1))
 static inline VALUE
 VM_ENV_ENVVAL(const VALUE *ep)
 {
@@ -1333,6 +1406,7 @@ VM_ENV_ENVVAL(const VALUE *ep)
     return envval;
 }
 
+RBIMPL_ATTR_NONNULL((1))
 static inline const rb_env_t *
 VM_ENV_ENVVAL_PTR(const VALUE *ep)
 {
@@ -1398,13 +1472,13 @@ VM_BH_ISEQ_BLOCK_P(VALUE block_handler)
 {
     if ((block_handler & 0x03) == 0x01) {
 #if VM_CHECK_MODE > 0
-   struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
-   VM_ASSERT(imemo_type_p(captured->code.val, imemo_iseq));
+	struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
+	VM_ASSERT(imemo_type_p(captured->code.val, imemo_iseq));
 #endif
-   return 1;
+	return 1;
     }
     else {
-   return 0;
+	return 0;
     }
 }
 
@@ -1429,13 +1503,13 @@ VM_BH_IFUNC_P(VALUE block_handler)
 {
     if ((block_handler & 0x03) == 0x03) {
 #if VM_CHECK_MODE > 0
-   struct rb_captured_block *captured = (void *)(block_handler & ~0x03);
-   VM_ASSERT(imemo_type_p(captured->code.val, imemo_ifunc));
+	struct rb_captured_block *captured = (void *)(block_handler & ~0x03);
+	VM_ASSERT(imemo_type_p(captured->code.val, imemo_ifunc));
 #endif
-   return 1;
+	return 1;
     }
     else {
-   return 0;
+	return 0;
     }
 }
 
@@ -1467,17 +1541,17 @@ static inline enum rb_block_handler_type
 vm_block_handler_type(VALUE block_handler)
 {
     if (VM_BH_ISEQ_BLOCK_P(block_handler)) {
-   return block_handler_type_iseq;
+	return block_handler_type_iseq;
     }
     else if (VM_BH_IFUNC_P(block_handler)) {
-   return block_handler_type_ifunc;
+	return block_handler_type_ifunc;
     }
     else if (SYMBOL_P(block_handler)) {
-   return block_handler_type_symbol;
+	return block_handler_type_symbol;
     }
     else {
-   VM_ASSERT(rb_obj_is_proc(block_handler));
-   return block_handler_type_proc;
+	VM_ASSERT(rb_obj_is_proc(block_handler));
+	return block_handler_type_proc;
     }
 }
 
@@ -1485,7 +1559,13 @@ static inline void
 vm_block_handler_verify(MAYBE_UNUSED(VALUE block_handler))
 {
     VM_ASSERT(block_handler == VM_BLOCK_HANDLER_NONE ||
-         (vm_block_handler_type(block_handler), 1));
+	      (vm_block_handler_type(block_handler), 1));
+}
+
+static inline int
+vm_cfp_forwarded_bh_p(const rb_control_frame_t *cfp, VALUE block_handler)
+{
+    return ((VALUE) cfp->block_code) == block_handler;
 }
 
 static inline enum rb_block_type
@@ -1494,17 +1574,17 @@ vm_block_type(const struct rb_block *block)
 #if VM_CHECK_MODE > 0
     switch (block->type) {
       case block_type_iseq:
-   VM_ASSERT(imemo_type_p(block->as.captured.code.val, imemo_iseq));
-   break;
+	VM_ASSERT(imemo_type_p(block->as.captured.code.val, imemo_iseq));
+	break;
       case block_type_ifunc:
-   VM_ASSERT(imemo_type_p(block->as.captured.code.val, imemo_ifunc));
-   break;
+	VM_ASSERT(imemo_type_p(block->as.captured.code.val, imemo_ifunc));
+	break;
       case block_type_symbol:
-   VM_ASSERT(SYMBOL_P(block->as.symbol));
-   break;
+	VM_ASSERT(SYMBOL_P(block->as.symbol));
+	break;
       case block_type_proc:
-   VM_ASSERT(rb_obj_is_proc(block->as.proc));
-   break;
+	VM_ASSERT(rb_obj_is_proc(block->as.proc));
+	break;
     }
 #endif
     return block->type;
@@ -1571,11 +1651,11 @@ vm_block_self(const struct rb_block *block)
     switch (vm_block_type(block)) {
       case block_type_iseq:
       case block_type_ifunc:
-   return block->as.captured.self;
+	return block->as.captured.self;
       case block_type_proc:
-   return vm_block_self(vm_proc_block(block->as.proc));
+	return vm_block_self(vm_proc_block(block->as.proc));
       case block_type_symbol:
-   return Qundef;
+	return Qundef;
     }
     VM_UNREACHABLE(vm_block_self);
     return Qundef;
@@ -1627,7 +1707,8 @@ extern void rb_vmdebug_debug_print_post(const rb_execution_context_t *ec, const
 #define SDR() rb_vmdebug_stack_dump_raw(GET_EC(), GET_EC()->cfp)
 #define SDR2(cfp) rb_vmdebug_stack_dump_raw(GET_EC(), (cfp))
 void rb_vm_bugreport(const void *);
-typedef RETSIGTYPE (*ruby_sighandler_t)(int);
+typedef void (*ruby_sighandler_t)(int);
+RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 4, 5)
 NORETURN(void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *, const char *fmt, ...));
 
 /* functions about thread/vm execution */
@@ -1664,13 +1745,12 @@ VALUE rb_vm_env_local_variables(const rb_env_t *env);
 const rb_env_t *rb_vm_env_prev_env(const rb_env_t *env);
 const VALUE *rb_binding_add_dynavars(VALUE bindval, rb_binding_t *bind, int dyncount, const ID *dynvars);
 void rb_vm_inc_const_missing_count(void);
-void rb_vm_gvl_destroy(rb_vm_t *vm);
-VALUE rb_vm_call(rb_execution_context_t *ec, VALUE recv, VALUE id, int argc,
-        const VALUE *argv, const rb_callable_method_entry_t *me);
 VALUE rb_vm_call_kw(rb_execution_context_t *ec, VALUE recv, VALUE id, int argc,
                  const VALUE *argv, const rb_callable_method_entry_t *me, int kw_splat);
 MJIT_STATIC void rb_vm_pop_frame(rb_execution_context_t *ec);
 
+void rb_gvl_destroy(rb_global_vm_lock_t *gvl);
+
 void rb_thread_start_timer_thread(void);
 void rb_thread_stop_timer_thread(void);
 void rb_thread_reset_timer_thread(void);
@@ -1683,22 +1763,7 @@ rb_vm_living_threads_init(rb_vm_t *vm)
     list_head_init(&vm->waiting_pids);
     list_head_init(&vm->workqueue);
     list_head_init(&vm->waiting_grps);
-    list_head_init(&vm->living_threads);
-    vm->living_thread_num = 0;
-}
-
-static inline void
-rb_vm_living_threads_insert(rb_vm_t *vm, rb_thread_t *th)
-{
-    list_add_tail(&vm->living_threads, &th->vmlt_node);
-    vm->living_thread_num++;
-}
-
-static inline void
-rb_vm_living_threads_remove(rb_vm_t *vm, rb_thread_t *th)
-{
-    list_del(&th->vmlt_node);
-    vm->living_thread_num--;
+    list_head_init(&vm->ractor.set);
 }
 
 typedef int rb_backtrace_iter_func(void *, VALUE, int, VALUE);
@@ -1707,6 +1772,8 @@ rb_control_frame_t *rb_vm_get_binding_creatable_next_cfp(const rb_execution_cont
 int rb_vm_get_sourceline(const rb_control_frame_t *);
 void rb_vm_stack_to_heap(rb_execution_context_t *ec);
 void ruby_thread_init_stack(rb_thread_t *th);
+rb_thread_t * ruby_thread_from_native(void);
+int ruby_thread_set_native(rb_thread_t *th);
 int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp);
 void rb_vm_rewind_cfp(rb_execution_context_t *ec, rb_control_frame_t *cfp);
 MJIT_STATIC VALUE rb_vm_bh_to_procval(const rb_execution_context_t *ec, VALUE block_handler);
@@ -1724,36 +1791,39 @@ MJIT_STATIC const rb_callable_method_entry_t *rb_vm_frame_method_entry(const rb_
 
 #define sysstack_error GET_VM()->special_exceptions[ruby_error_sysstack]
 
-#define RUBY_CONST_ASSERT(expr) (1/!!(expr)) /* expr must be a compile-time constant */
-#define VM_STACK_OVERFLOWED_P(cfp, sp, margin) \
-    (!RUBY_CONST_ASSERT(sizeof(*(sp)) == sizeof(VALUE)) || \
-     !RUBY_CONST_ASSERT(sizeof(*(cfp)) == sizeof(rb_control_frame_t)) || \
-     ((rb_control_frame_t *)((sp) + (margin)) + 1) >= (cfp))
-#define WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) \
-    if (LIKELY(!VM_STACK_OVERFLOWED_P(cfp, sp, margin))) {(void)0;} else /* overflowed */
-#define CHECK_VM_STACK_OVERFLOW0(cfp, sp, margin) \
-    WHEN_VM_STACK_OVERFLOWED(cfp, sp, margin) vm_stackoverflow()
+#define CHECK_VM_STACK_OVERFLOW0(cfp, sp, margin) do {                       \
+    STATIC_ASSERT(sizeof_sp,  sizeof(*(sp))  == sizeof(VALUE));              \
+    STATIC_ASSERT(sizeof_cfp, sizeof(*(cfp)) == sizeof(rb_control_frame_t)); \
+    const struct rb_control_frame_struct *bound = (void *)&(sp)[(margin)];   \
+    if (UNLIKELY((cfp) <= &bound[1])) {                                      \
+        vm_stackoverflow();                                                  \
+    }                                                                        \
+} while (0)
+
 #define CHECK_VM_STACK_OVERFLOW(cfp, margin) \
-    WHEN_VM_STACK_OVERFLOWED(cfp, (cfp)->sp, margin) vm_stackoverflow()
+    CHECK_VM_STACK_OVERFLOW0((cfp), (cfp)->sp, (margin))
 
 VALUE rb_catch_protect(VALUE t, rb_block_call_func *func, VALUE data, enum ruby_tag_type *stateptr);
 
+rb_execution_context_t *rb_vm_main_ractor_ec(rb_vm_t *vm); // ractor.c
+
 /* for thread */
 
 #if RUBY_VM_THREAD_MODEL == 2
-RUBY_SYMBOL_EXPORT_BEGIN
+MJIT_SYMBOL_EXPORT_BEGIN
 
+RUBY_EXTERN struct rb_ractor_struct *ruby_single_main_ractor; // ractor.c
 RUBY_EXTERN rb_vm_t *ruby_current_vm_ptr;
-RUBY_EXTERN rb_execution_context_t *ruby_current_execution_context_ptr;
 RUBY_EXTERN rb_event_flag_t ruby_vm_event_flags;
 RUBY_EXTERN rb_event_flag_t ruby_vm_event_enabled_global_flags;
 RUBY_EXTERN unsigned int    ruby_vm_event_local_num;
 
-RUBY_SYMBOL_EXPORT_END
+MJIT_SYMBOL_EXPORT_END
 
 #define GET_VM()     rb_current_vm()
+#define GET_RACTOR() rb_current_ractor()
 #define GET_THREAD() rb_current_thread()
-#define GET_EC()     rb_current_execution_context()
+#define GET_EC()     rb_current_execution_context(true)
 
 static inline rb_thread_t *
 rb_ec_thread_ptr(const rb_execution_context_t *ec)
@@ -1761,22 +1831,45 @@ rb_ec_thread_ptr(const rb_execution_context_t *ec)
     return ec->thread_ptr;
 }
 
+static inline rb_ractor_t *
+rb_ec_ractor_ptr(const rb_execution_context_t *ec)
+{
+    const rb_thread_t *th = rb_ec_thread_ptr(ec);
+    if (th) {
+        VM_ASSERT(th->ractor != NULL);
+	return th->ractor;
+    }
+    else {
+        return NULL;
+    }
+}
+
 static inline rb_vm_t *
 rb_ec_vm_ptr(const rb_execution_context_t *ec)
 {
     const rb_thread_t *th = rb_ec_thread_ptr(ec);
     if (th) {
-   return th->vm;
+	return th->vm;
     }
     else {
-   return NULL;
+	return NULL;
     }
 }
 
 static inline rb_execution_context_t *
-rb_current_execution_context(void)
-{
-    return ruby_current_execution_context_ptr;
+rb_current_execution_context(bool expect_ec)
+{
+#ifdef RB_THREAD_LOCAL_SPECIFIER
+  #ifdef __APPLE__
+    rb_execution_context_t *ec = rb_current_ec();
+  #else
+    rb_execution_context_t *ec = ruby_current_ec;
+  #endif
+#else
+    rb_execution_context_t *ec = native_tls_get(ruby_current_ec_key);
+#endif
+    VM_ASSERT(!expect_ec || ec != NULL);
+    return ec;
 }
 
 static inline rb_thread_t *
@@ -1786,30 +1879,47 @@ rb_current_thread(void)
     return rb_ec_thread_ptr(ec);
 }
 
+static inline rb_ractor_t *
+rb_current_ractor(void)
+{
+    if (ruby_single_main_ractor) {
+        return ruby_single_main_ractor;
+    }
+    else {
+        const rb_execution_context_t *ec = GET_EC();
+        return rb_ec_ractor_ptr(ec);
+    }
+}
+
 static inline rb_vm_t *
 rb_current_vm(void)
 {
+#if 0 // TODO: reconsider the assertions
     VM_ASSERT(ruby_current_vm_ptr == NULL ||
-         ruby_current_execution_context_ptr == NULL ||
-         rb_ec_thread_ptr(GET_EC()) == NULL ||
-         rb_ec_vm_ptr(GET_EC()) == ruby_current_vm_ptr);
+	      ruby_current_execution_context_ptr == NULL ||
+	      rb_ec_thread_ptr(GET_EC()) == NULL ||
+              rb_ec_thread_ptr(GET_EC())->status == THREAD_KILLED ||
+	      rb_ec_vm_ptr(GET_EC()) == ruby_current_vm_ptr);
+#endif
+
     return ruby_current_vm_ptr;
 }
 
-static inline void
-rb_thread_set_current_raw(const rb_thread_t *th)
-{
-    ruby_current_execution_context_ptr = th->ec;
-}
+void rb_ec_vm_lock_rec_release(const rb_execution_context_t *ec,
+                               unsigned int recorded_lock_rec,
+                               unsigned int current_lock_rec);
 
-static inline void
-rb_thread_set_current(rb_thread_t *th)
+static inline unsigned int
+rb_ec_vm_lock_rec(const rb_execution_context_t *ec)
 {
-    if (th->vm->running_thread != th) {
-        th->running_time_us = 0;
+    rb_vm_t *vm = rb_ec_vm_ptr(ec);
+
+    if (vm->ractor.sync.lock_owner != rb_ec_ractor_ptr(ec)) {
+        return 0;
+    }
+    else {
+        return vm->ractor.sync.lock_rec;
     }
-    rb_thread_set_current_raw(th);
-    th->vm->running_thread = th;
 }
 
 #else
@@ -1820,16 +1930,33 @@ enum {
     TIMER_INTERRUPT_MASK         = 0x01,
     PENDING_INTERRUPT_MASK       = 0x02,
     POSTPONED_JOB_INTERRUPT_MASK = 0x04,
-    TRAP_INTERRUPT_MASK             = 0x08
+    TRAP_INTERRUPT_MASK	         = 0x08,
+    TERMINATE_INTERRUPT_MASK     = 0x10,
+    VM_BARRIER_INTERRUPT_MASK    = 0x20,
 };
 
-#define RUBY_VM_SET_TIMER_INTERRUPT(ec)        ATOMIC_OR((ec)->interrupt_flag, TIMER_INTERRUPT_MASK)
-#define RUBY_VM_SET_INTERRUPT(ec)      ATOMIC_OR((ec)->interrupt_flag, PENDING_INTERRUPT_MASK)
-#define RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(ec)    ATOMIC_OR((ec)->interrupt_flag, POSTPONED_JOB_INTERRUPT_MASK)
-#define RUBY_VM_SET_TRAP_INTERRUPT(ec)     ATOMIC_OR((ec)->interrupt_flag, TRAP_INTERRUPT_MASK)
-#define RUBY_VM_INTERRUPTED(ec)            ((ec)->interrupt_flag & ~(ec)->interrupt_mask & \
-                        (PENDING_INTERRUPT_MASK|TRAP_INTERRUPT_MASK))
-#define RUBY_VM_INTERRUPTED_ANY(ec)        ((ec)->interrupt_flag & ~(ec)->interrupt_mask)
+#define RUBY_VM_SET_TIMER_INTERRUPT(ec)		ATOMIC_OR((ec)->interrupt_flag, TIMER_INTERRUPT_MASK)
+#define RUBY_VM_SET_INTERRUPT(ec)		ATOMIC_OR((ec)->interrupt_flag, PENDING_INTERRUPT_MASK)
+#define RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(ec)	ATOMIC_OR((ec)->interrupt_flag, POSTPONED_JOB_INTERRUPT_MASK)
+#define RUBY_VM_SET_TRAP_INTERRUPT(ec)		ATOMIC_OR((ec)->interrupt_flag, TRAP_INTERRUPT_MASK)
+#define RUBY_VM_SET_TERMINATE_INTERRUPT(ec)     ATOMIC_OR((ec)->interrupt_flag, TERMINATE_INTERRUPT_MASK)
+#define RUBY_VM_SET_VM_BARRIER_INTERRUPT(ec)    ATOMIC_OR((ec)->interrupt_flag, VM_BARRIER_INTERRUPT_MASK)
+#define RUBY_VM_INTERRUPTED(ec)			((ec)->interrupt_flag & ~(ec)->interrupt_mask & \
+						 (PENDING_INTERRUPT_MASK|TRAP_INTERRUPT_MASK))
+
+static inline bool
+RUBY_VM_INTERRUPTED_ANY(rb_execution_context_t *ec)
+{
+#if defined(USE_VM_CLOCK) && USE_VM_CLOCK
+    uint32_t current_clock = rb_ec_vm_ptr(ec)->clock;
+
+    if (current_clock != ec->checked_clock) {
+        ec->checked_clock = current_clock;
+        RUBY_VM_SET_TIMER_INTERRUPT(ec);
+    }
+#endif
+    return ec->interrupt_flag & ~(ec)->interrupt_mask;
+}
 
 VALUE rb_exc_set_backtrace(VALUE exc, VALUE bt);
 int rb_signal_buff_size(void);
@@ -1842,11 +1969,17 @@ void rb_threadptr_interrupt(rb_thread_t *th);
 void rb_threadptr_unlock_all_locking_mutexes(rb_thread_t *th);
 void rb_threadptr_pending_interrupt_clear(rb_thread_t *th);
 void rb_threadptr_pending_interrupt_enque(rb_thread_t *th, VALUE v);
+VALUE rb_ec_get_errinfo(const rb_execution_context_t *ec);
 void rb_ec_error_print(rb_execution_context_t * volatile ec, volatile VALUE errinfo);
 void rb_execution_context_update(const rb_execution_context_t *ec);
 void rb_execution_context_mark(const rb_execution_context_t *ec);
 void rb_fiber_close(rb_fiber_t *fib);
 void Init_native_thread(rb_thread_t *th);
+int rb_vm_check_ints_blocking(rb_execution_context_t *ec);
+
+// vm_sync.h
+void rb_vm_cond_wait(rb_vm_t *vm, rb_nativethread_cond_t *cond);
+void rb_vm_cond_timedwait(rb_vm_t *vm, rb_nativethread_cond_t *cond, unsigned long msec);
 
 #define RUBY_VM_CHECK_INTS(ec) rb_vm_check_ints(ec)
 static inline void
@@ -1854,7 +1987,7 @@ rb_vm_check_ints(rb_execution_context_t *ec)
 {
     VM_ASSERT(ec == GET_EC());
     if (UNLIKELY(RUBY_VM_INTERRUPTED_ANY(ec))) {
-   rb_threadptr_execute_interrupts(rb_ec_thread_ptr(ec), 0);
+	rb_threadptr_execute_interrupts(rb_ec_thread_ptr(ec), 0);
     }
 }
 
@@ -1915,17 +2048,24 @@ rb_exec_event_hook_orig(rb_execution_context_t *ec, rb_hook_list_t *hooks, rb_ev
     rb_exec_event_hooks(&trace_arg, hooks, pop_p);
 }
 
+struct rb_ractor_pub {
+    VALUE self;
+    uint32_t id;
+    rb_hook_list_t hooks;
+};
+
 static inline rb_hook_list_t *
-rb_vm_global_hooks(const rb_execution_context_t *ec)
+rb_ec_ractor_hooks(const rb_execution_context_t *ec)
 {
-    return &rb_ec_vm_ptr(ec)->global_hooks;
+    struct rb_ractor_pub *cr_pub = (struct rb_ractor_pub *)rb_ec_ractor_ptr(ec);
+    return &cr_pub->hooks;
 }
 
 #define EXEC_EVENT_HOOK(ec_, flag_, self_, id_, called_id_, klass_, data_) \
-  EXEC_EVENT_HOOK_ORIG(ec_, rb_vm_global_hooks(ec_), flag_, self_, id_, called_id_, klass_, data_, 0)
+  EXEC_EVENT_HOOK_ORIG(ec_, rb_ec_ractor_hooks(ec_), flag_, self_, id_, called_id_, klass_, data_, 0)
 
 #define EXEC_EVENT_HOOK_AND_POP_FRAME(ec_, flag_, self_, id_, called_id_, klass_, data_) \
-  EXEC_EVENT_HOOK_ORIG(ec_, rb_vm_global_hooks(ec_), flag_, self_, id_, called_id_, klass_, data_, 1)
+  EXEC_EVENT_HOOK_ORIG(ec_, rb_ec_ractor_hooks(ec_), flag_, self_, id_, called_id_, klass_, data_, 1)
 
 static inline void
 rb_exec_event_hook_script_compiled(rb_execution_context_t *ec, const rb_iseq_t *iseq, VALUE eval_script)
@@ -1949,9 +2089,15 @@ extern VALUE rb_get_coverages(void);
 extern void rb_set_coverages(VALUE, int, VALUE);
 extern void rb_clear_coverages(void);
 extern void rb_reset_coverages(void);
+extern void rb_resume_coverages(void);
+extern void rb_suspend_coverages(void);
 
 void rb_postponed_job_flush(rb_vm_t *vm);
 
+// ractor.c
+RUBY_EXTERN VALUE rb_eRactorUnsafeError;
+RUBY_EXTERN VALUE rb_eRactorIsolationError;
+
 RUBY_SYMBOL_EXPORT_END
 
 #endif /* RUBY_VM_CORE_H */