debase-ruby_core_source 0.10.9 → 0.10.13

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.0.0-p0}/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,27 +62,21 @@
 #define VM_UNREACHABLE(func) UNREACHABLE
 #endif
 
-#define RUBY_VM_THREAD_MODEL 2
-
-/*
- * implementation selector of get_insn_info algorithm
- *   0: linear search
- *   1: binary search
- *   2: succinct bitvector
- */
-#ifndef VM_INSN_INFO_TABLE_IMPL
-# define VM_INSN_INFO_TABLE_IMPL 2
-#endif
-
-#include "ruby/ruby.h"
-#include "ruby/st.h"
+#include <setjmp.h>
 
-#include "node.h"
-#include "vm_opts.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 "ccan/list/list.h"
+#include "vm_opts.h"
 
 #include "ruby/thread_native.h"
 #if   defined(_WIN32)
@@ -86,8 +85,17 @@
 #include "thread_pthread.h"
 #endif
 
-#include <setjmp.h>
-#include <signal.h>
+#define RUBY_VM_THREAD_MODEL 2
+
+/*
+ * implementation selector of get_insn_info algorithm
+ *   0: linear search
+ *   1: binary search
+ *   2: succinct bitvector
+ */
+#ifndef VM_INSN_INFO_TABLE_IMPL
+# define VM_INSN_INFO_TABLE_IMPL 2
+#endif
 
 #if defined(NSIG_MAX)           /* POSIX issue 8 */
 # undef NSIG
@@ -123,22 +131,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()
+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) xfree(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
@@ -220,10 +221,11 @@ 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;
+    VALUE value;
+};
+
+struct iseq_inline_iv_cache_entry {
+    struct rb_iv_index_tbl_entry *entry;
 };
 
 union iseq_inline_storage_entry {
@@ -232,26 +234,12 @@ union iseq_inline_storage_entry {
 	VALUE value;
     } once;
     struct iseq_inline_cache_entry cache;
-};
-
-struct rb_call_info {
-    /* fixed at compile time */
-    ID mid;
-    unsigned int flag;
-    int orig_argc;
-};
-
-struct rb_call_info_kw_arg {
-    int keyword_len;
-    VALUE keywords[1];
-};
-
-struct rb_call_info_with_kwarg {
-    struct rb_call_info ci;
-    struct rb_call_info_kw_arg *kw_arg;
+    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;
@@ -259,7 +247,6 @@ struct rb_calling_info {
 };
 
 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, const struct rb_call_info *ci, struct rb_call_cache *cc);
 
 #if 1
 #define CoreDataFromValue(obj, type) (type*)DATA_PTR(obj)
@@ -417,12 +404,7 @@ 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_info *ci_entries; /* struct rb_call_info ci_entries[ci_size];
-				      * struct rb_call_info_with_kwarg cikw_entries[ci_kw_size];
-				      * So that:
-				      * struct rb_call_info_with_kwarg *cikw_entries = &body->ci_entries[ci_size];
-				      */
-    struct rb_call_cache *cc_entries; /* size is ci_size + ci_kw_size */
+    struct rb_call_data *call_data; //struct rb_call_data calls[ci_size];
 
     struct {
 	rb_snum_t flip_count;
@@ -434,10 +416,11 @@ struct rb_iseq_constant_body {
     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 */
+    bool builtin_inline_p; // This ISeq's builtin func is safe to be inlined by MJIT
+    struct rb_id_table *outer_variables;
 
 #if USE_MJIT
     /* The following fields are MJIT related info.  */
@@ -493,6 +476,7 @@ rb_iseq_check(const rb_iseq_t *iseq)
 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 VM_CHECK_MODE > 0
     if (def->type != VM_METHOD_TYPE_ISEQ) rb_bug("def_iseq_ptr: not iseq (%d)", def->type);
 #endif
@@ -565,15 +549,37 @@ typedef struct rb_hook_list_struct {
     unsigned int running;
 } rb_hook_list_t;
 
+
+// see builtin.h for definition
+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;
@@ -584,9 +590,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;
@@ -594,9 +597,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;
@@ -616,18 +617,14 @@ typedef struct rb_vm_struct {
     /* signal */
     struct {
 	VALUE cmd[RUBY_NSIG];
-	unsigned char safe[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;
 
@@ -635,7 +632,7 @@ 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 orig_progname, progname;
     VALUE coverages;
     int coverage_mode;
 
@@ -648,6 +645,15 @@ typedef struct rb_vm_struct {
     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;
+
+#if USE_VM_CLOCK
+    uint32_t clock;
+#endif
+
     /* params */
     struct { /* size in byte */
 	size_t thread_vm_stack_size;
@@ -753,7 +759,7 @@ typedef struct rb_control_frame_struct {
     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 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
@@ -792,6 +798,7 @@ 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);
@@ -810,11 +817,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);
@@ -830,7 +832,13 @@ 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 */
     size_t vm_stack_size;       /* size in word (byte size / sizeof(VALUE)) */
@@ -842,12 +850,15 @@ typedef struct rb_execution_context_struct {
     /* interrupt flags */
     rb_atomic_t interrupt_flag;
     rb_atomic_t interrupt_mask; /* size should match flag */
+#if 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,7 +890,15 @@ typedef struct rb_execution_context_struct {
 	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
 
 // Set the vm_stack pointer in the execution context.
 void rb_ec_set_vm_stack(rb_execution_context_t *ec, VALUE *stack, size_t size);
@@ -894,9 +913,16 @@ 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;
+
 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;
@@ -945,7 +971,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 {
@@ -959,9 +985,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;
 
@@ -972,9 +999,17 @@ typedef struct rb_thread_struct {
     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 {
@@ -996,11 +1031,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;
@@ -1019,10 +1056,6 @@ rb_iseq_t *rb_iseq_new_with_callback(const struct rb_iseq_new_with_callback_call
     VALUE name, VALUE path, VALUE realpath, VALUE first_lineno,
     const rb_iseq_t *parent, enum iseq_type, const rb_compile_option_t*);
 
-/* src -> iseq */
-rb_iseq_t *rb_iseq_compile(VALUE src, VALUE file, VALUE line);
-rb_iseq_t *rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE realpath, VALUE line, VALUE opt);
-
 VALUE rb_iseq_disasm(const rb_iseq_t *iseq);
 int rb_iseq_disasm_insn(VALUE str, const VALUE *iseqval, size_t pos, const rb_iseq_t *iseq, VALUE child);
 
@@ -1041,8 +1074,13 @@ typedef struct {
     const struct rb_block block;
     unsigned int is_from_method: 1;	/* bool */
     unsigned int is_lambda: 1;		/* bool */
+    unsigned int is_isolated: 1;        /* bool */
 } rb_proc_t;
 
+VALUE rb_proc_isolate(VALUE self);
+VALUE rb_proc_isolate_bang(VALUE self);
+VALUE rb_proc_ractor_make_shareable(VALUE self);
+
 typedef struct {
     VALUE flags; /* imemo header */
     rb_iseq_t *iseq;
@@ -1073,35 +1111,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,
@@ -1118,11 +1127,11 @@ enum vm_svar_index {
 
 /* inline cache */
 typedef struct iseq_inline_cache_entry *IC;
+typedef struct iseq_inline_iv_cache_entry *IVC;
 typedef union iseq_inline_storage_entry *ISE;
-typedef struct rb_call_info *CALL_INFO;
-typedef struct rb_call_cache *CALL_CACHE;
-
-void rb_vm_change_state(void);
+typedef const struct rb_callinfo *CALL_INFO;
+typedef const struct rb_callcache *CALL_CACHE;
+typedef struct rb_call_data *CALL_DATA;
 
 typedef VALUE CDHASH;
 
@@ -1142,11 +1151,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)
      */
 
@@ -1164,19 +1173,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)
@@ -1232,13 +1241,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)
 {
@@ -1485,6 +1487,12 @@ vm_block_handler_verify(MAYBE_UNUSED(VALUE block_handler))
 	      (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
 vm_block_type(const struct rb_block *block)
 {
@@ -1624,7 +1632,7 @@ 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);
 NORETURN(void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *, const char *fmt, ...));
 
 /* functions about thread/vm execution */
@@ -1661,13 +1669,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);
@@ -1680,29 +1687,13 @@ 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);
 rb_control_frame_t *rb_vm_get_ruby_level_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp);
 rb_control_frame_t *rb_vm_get_binding_creatable_next_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp);
 int rb_vm_get_sourceline(const rb_control_frame_t *);
-VALUE rb_name_err_mesg_new(VALUE mesg, VALUE recv, VALUE method);
 void rb_vm_stack_to_heap(rb_execution_context_t *ec);
 void ruby_thread_init_stack(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);
@@ -1722,27 +1713,29 @@ 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
 
+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;
@@ -1750,6 +1743,7 @@ RUBY_EXTERN unsigned int    ruby_vm_event_local_num;
 RUBY_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()
 
@@ -1759,6 +1753,19 @@ 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)
 {
@@ -1774,7 +1781,17 @@ rb_ec_vm_ptr(const rb_execution_context_t *ec)
 static inline rb_execution_context_t *
 rb_current_execution_context(void)
 {
-    return ruby_current_execution_context_ptr;
+#ifdef RB_THREAD_LOCAL_SPECIFIER
+  #if __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(ec != NULL);
+    return ec;
 }
 
 static inline rb_thread_t *
@@ -1784,30 +1801,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_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
@@ -1818,16 +1852,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_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))
-#define RUBY_VM_INTERRUPTED_ANY(ec)		((ec)->interrupt_flag & ~(ec)->interrupt_mask)
+
+static inline bool
+RUBY_VM_INTERRUPTED_ANY(rb_execution_context_t *ec)
+{
+#if 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);
@@ -1840,11 +1891,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
@@ -1913,17 +1970,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)
@@ -1950,6 +2014,10 @@ extern void rb_reset_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 */