debase-ruby_core_source 0.10.9 → 0.10.13

data/lib/debase/ruby_core_source/ruby-3.1.0-preview1/vm_debug.h

@@ -0,0 +1,119 @@
+#ifndef RUBY_DEBUG_H
+#define RUBY_DEBUG_H
+/**********************************************************************
+
+  vm_debug.h - YARV Debug function interface
+
+  $Author$
+  created at: 04/08/25 02:33:49 JST
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+#include "ruby/ruby.h"
+#include "node.h"
+
+RUBY_SYMBOL_EXPORT_BEGIN
+
+#define dpv(h,v) ruby_debug_print_value(-1, 0, (h), (v))
+#define dp(v)    ruby_debug_print_value(-1, 0, "", (v))
+#define dpi(i)   ruby_debug_print_id(-1, 0, "", (i))
+#define dpn(n)   ruby_debug_print_node(-1, 0, "", (n))
+
+VALUE ruby_debug_print_value(int level, int debug_level, const char *header, VALUE v);
+ID    ruby_debug_print_id(int level, int debug_level, const char *header, ID id);
+NODE *ruby_debug_print_node(int level, int debug_level, const char *header, const NODE *node);
+int   ruby_debug_print_indent(int level, int debug_level, int indent_level);
+void  ruby_debug_gc_check_func(void);
+void ruby_set_debug_option(const char *str);
+
+RUBY_SYMBOL_EXPORT_END
+
+#if RUBY_DEVEL
+#ifndef USE_RUBY_DEBUG_LOG
+#define USE_RUBY_DEBUG_LOG 0
+#endif
+#else
+// disable on !RUBY_DEVEL
+#ifdef USE_RUBY_DEBUG_LOG
+#undef USE_RUBY_DEBUG_LOG
+#endif
+#endif
+
+/* RUBY_DEBUG_LOG: Logging debug information mechanism
+ *
+ * This feature provides a mechanism to store logging information
+ * to a file, stderr or memory space with simple macros.
+ *
+ * The following information will be stored.
+ *   * (1) __FILE__, __LINE__ in C
+ *   * (2) __FILE__, __LINE__ in Ruby
+ *   * (3) __func__ in C (message title)
+ *   * (4) given string with sprintf format
+ *   * (5) Thread number (if multiple threads are running)
+ *
+ * This feature is enabled only USE_RUBY_DEBUG_LOG is enabled.
+ * Release version should not enable it.
+ *
+ * Running with the `RUBY_DEBUG_LOG` environment variable enables
+ * this feature.
+ *
+ *   # logging into a file
+ *   RUBY_DEBUG_LOG=/path/to/file STDERR
+ *
+ *   # logging into STDERR
+ *   RUBY_DEBUG_LOG=stderr
+ *
+ *   # logging into memory space (check with a debugger)
+ *   # It will help if the timing is important.
+ *   RUBY_DEBUG_LOG=mem
+ *
+ * RUBY_DEBUG_LOG_FILTER environment variable can specify the filter string.
+ * If "(3) __func__ in C (message title)" contains the specified string, the
+ * information will be stored (example: RUBY_DEBUG_LOG_FILTER=str will enable
+ * only on str related information).
+ *
+ * In a MRI source code, you can use the following macros:
+ *   * RUBY_DEBUG_LOG(fmt, ...): Above (1) to (4) will be logged.
+ *   * RUBY_DEBUG_LOG2(file, line, fmt, ...):
+ *     Same as RUBY_DEBUG_LOG(), but (1) will be replaced with given file, line.
+ */
+
+extern enum ruby_debug_log_mode {
+    ruby_debug_log_disabled = 0x00,
+    ruby_debug_log_memory   = 0x01,
+    ruby_debug_log_stderr   = 0x02,
+    ruby_debug_log_file     = 0x04,
+} ruby_debug_log_mode;
+
+RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 4, 5)
+void ruby_debug_log(const char *file, int line, const char *func_name, const char *fmt, ...);
+void ruby_debug_log_print(unsigned int n);
+bool ruby_debug_log_filter(const char *func_name);
+
+// convenient macro to log even if the USE_RUBY_DEBUG_LOG macro is not specified.
+// You can use this macro for temporary usage (you should not commit it).
+#define _RUBY_DEBUG_LOG(...) ruby_debug_log(__FILE__, __LINE__, RUBY_FUNCTION_NAME_STRING, "" __VA_ARGS__)
+
+#if USE_RUBY_DEBUG_LOG
+# define RUBY_DEBUG_LOG_ENABLED(func_name) \
+    (ruby_debug_log_mode && ruby_debug_log_filter(func_name))
+
+#define RUBY_DEBUG_LOG(...) do { \
+    if (RUBY_DEBUG_LOG_ENABLED(RUBY_FUNCTION_NAME_STRING)) \
+        ruby_debug_log(__FILE__, __LINE__, RUBY_FUNCTION_NAME_STRING, "" __VA_ARGS__); \
+} while (0)
+
+#define RUBY_DEBUG_LOG2(file, line, ...) do { \
+    if (RUBY_DEBUG_LOG_ENABLED(RUBY_FUNCTION_NAME_STRING)) \
+        ruby_debug_log(file, line, RUBY_FUNCTION_NAME_STRING, "" __VA_ARGS__); \
+} while (0)
+
+#else
+// do nothing
+#define RUBY_DEBUG_LOG(...)
+#define RUBY_DEBUG_LOG2(file, line, ...)
+#endif // USE_RUBY_DEBUG_LOG
+
+#endif /* RUBY_DEBUG_H */

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

@@ -1,3 +1,5 @@
+#ifndef RUBY_VM_EXEC_H
+#define RUBY_VM_EXEC_H
 /**********************************************************************
 
   vm.h -
@@ -9,9 +11,6 @@
 
 **********************************************************************/
 
-#ifndef RUBY_VM_EXEC_H
-#define RUBY_VM_EXEC_H
-
 typedef long OFFSET;
 typedef unsigned long lindex_t;
 typedef VALUE GENTRY;
@@ -38,8 +37,12 @@ typedef rb_iseq_t *ISEQ;
 #define DEBUG_END_INSN()
 #endif
 
-#define throwdebug if(0)printf
-/* #define throwdebug printf */
+#define throwdebug if(0)ruby_debug_printf
+/* #define throwdebug ruby_debug_printf */
+
+#ifndef USE_INSNS_COUNTER
+#define USE_INSNS_COUNTER 0
+#endif
 
 /************************************************/
 #if defined(DISPATCH_XXX)
@@ -71,11 +74,14 @@ error !
 #define LABEL_PTR(x) RB_GNUC_EXTENSION(&&LABEL(x))
 
 #define INSN_ENTRY_SIG(insn) \
-  if (0) fprintf(stderr, "exec: %s@(%"PRIdPTRDIFF", %"PRIdPTRDIFF")@%s:%u\n", #insn, \
-                 (reg_pc - reg_cfp->iseq->body->iseq_encoded), \
-                 (reg_cfp->pc - reg_cfp->iseq->body->iseq_encoded), \
-                 RSTRING_PTR(rb_iseq_path(reg_cfp->iseq)), \
-                 rb_iseq_line_no(reg_cfp->iseq, reg_pc - reg_cfp->iseq->body->iseq_encoded));
+  if (0) { \
+      ruby_debug_printf("exec: %s@(%"PRIdPTRDIFF", %"PRIdPTRDIFF")@%s:%u\n", #insn, \
+                        (reg_pc - reg_cfp->iseq->body->iseq_encoded), \
+                        (reg_cfp->pc - reg_cfp->iseq->body->iseq_encoded), \
+                        RSTRING_PTR(rb_iseq_path(reg_cfp->iseq)), \
+                        rb_iseq_line_no(reg_cfp->iseq, reg_pc - reg_cfp->iseq->body->iseq_encoded)); \
+  } \
+  if (USE_INSNS_COUNTER) vm_insns_counter_count_insn(BIN(insn));
 
 #define INSN_DISPATCH_SIG(insn)
 
@@ -126,9 +132,6 @@ error !
 
 #define NEXT_INSN() TC_DISPATCH(__NEXT_INSN__)
 
-#define START_OF_ORIGINAL_INSN(x) start_of_##x:
-#define DISPATCH_ORIGINAL_INSN(x) goto  start_of_##x;
-
 /************************************************/
 #else /* no threaded code */
 /* most common method */
@@ -141,7 +144,7 @@ case BIN(insn):
   break;
 
 #define INSN_DISPATCH()         \
-  while (1) {          \
+  while (1) {			\
     switch (GET_CURRENT_INSN()) {
 
 #define END_INSNS_DISPATCH()    \
@@ -153,9 +156,11 @@ default:                        \
 
 #define NEXT_INSN() goto first
 
-#define START_OF_ORIGINAL_INSN(x) start_of_##x:
-#define DISPATCH_ORIGINAL_INSN(x) goto  start_of_##x;
+#endif
 
+#ifndef START_OF_ORIGINAL_INSN
+#define START_OF_ORIGINAL_INSN(x) if (0) goto start_of_##x; start_of_##x:
+#define DISPATCH_ORIGINAL_INSN(x) goto  start_of_##x;
 #endif
 
 #define VM_SP_CNT(ec, sp) ((sp) - (ec)->vm_stack)
@@ -181,8 +186,7 @@ default:                        \
 #define VM_DEBUG_STACKOVERFLOW 0
 
 #if VM_DEBUG_STACKOVERFLOW
-#define CHECK_VM_STACK_OVERFLOW_FOR_INSN(cfp, margin) \
-    WHEN_VM_STACK_OVERFLOWED(cfp, (cfp)->sp, margin) vm_stack_overflow_for_insn()
+#define CHECK_VM_STACK_OVERFLOW_FOR_INSN CHECK_VM_STACK_OVERFLOW
 #else
 #define CHECK_VM_STACK_OVERFLOW_FOR_INSN(cfp, margin)
 #endif

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

@@ -1,3 +1,5 @@
+#ifndef RUBY_INSNHELPER_H
+#define RUBY_INSNHELPER_H
 /**********************************************************************
 
   insnhelper.h - helper macros to implement each instructions
@@ -9,27 +11,29 @@
 
 **********************************************************************/
 
-#ifndef RUBY_INSNHELPER_H
-#define RUBY_INSNHELPER_H
-
-RUBY_SYMBOL_EXPORT_BEGIN
+MJIT_SYMBOL_EXPORT_BEGIN
 
 RUBY_EXTERN VALUE ruby_vm_const_missing_count;
-RUBY_EXTERN rb_serial_t ruby_vm_global_method_state;
 RUBY_EXTERN rb_serial_t ruby_vm_global_constant_state;
 RUBY_EXTERN rb_serial_t ruby_vm_class_serial;
+RUBY_EXTERN rb_serial_t ruby_vm_global_cvar_state;
 
-RUBY_SYMBOL_EXPORT_END
+MJIT_SYMBOL_EXPORT_END
 
 #if VM_COLLECT_USAGE_DETAILS
 #define COLLECT_USAGE_INSN(insn)           vm_collect_usage_insn(insn)
 #define COLLECT_USAGE_OPERAND(insn, n, op) vm_collect_usage_operand((insn), (n), ((VALUE)(op)))
 
 #define COLLECT_USAGE_REGISTER(reg, s)     vm_collect_usage_register((reg), (s))
+#elif YJIT_STATS
+/* for --yjit-stats */
+#define COLLECT_USAGE_INSN(insn)           rb_yjit_collect_vm_usage_insn(insn)
+#define COLLECT_USAGE_OPERAND(insn, n, op)	/* none */
+#define COLLECT_USAGE_REGISTER(reg, s)		/* none */
 #else
-#define COLLECT_USAGE_INSN(insn)       /* none */
-#define COLLECT_USAGE_OPERAND(insn, n, op) /* none */
-#define COLLECT_USAGE_REGISTER(reg, s)     /* none */
+#define COLLECT_USAGE_INSN(insn)		/* none */
+#define COLLECT_USAGE_OPERAND(insn, n, op)	/* none */
+#define COLLECT_USAGE_REGISTER(reg, s)		/* none */
 #endif
 
 /**********************************************************/
@@ -94,7 +98,7 @@ enum vm_regan_acttype {
 #define SET_SP(x)  (VM_REG_SP  = (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
 #define INC_SP(x)  (VM_REG_SP += (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
 #define DEC_SP(x)  (VM_REG_SP -= (COLLECT_USAGE_REGISTER_HELPER(SP, SET, (x))))
-#define SET_SV(x)  (*GET_SP() = (x))
+#define SET_SV(x)  (*GET_SP() = rb_ractor_confirm_belonging(x))
   /* set current stack value as x */
 
 /* instruction sequence C struct */
@@ -120,9 +124,13 @@ enum vm_regan_acttype {
  * because inline method cache does not care about receiver.
  */
 
-#define CC_SET_FASTPATH(cc, func, enabled) do { \
-    if (LIKELY(enabled)) ((cc)->call = (func)); \
-} while (0)
+static inline void
+CC_SET_FASTPATH(const struct rb_callcache *cc, vm_call_handler func, bool enabled)
+{
+    if (LIKELY(enabled)) {
+        vm_cc_call_set(cc, func);
+    }
+}
 
 #define GET_BLOCK_HANDLER() (GET_LEP()[VM_ENV_DATA_INDEX_SPECVAL])
 
@@ -136,27 +144,27 @@ enum vm_regan_acttype {
 /**********************************************************/
 
 #if VM_CHECK_MODE > 0
-#define SETUP_CANARY() \
-    VALUE *canary; \
-    if (leaf) { \
+#define SETUP_CANARY(cond) \
+    VALUE *canary = 0; \
+    if (cond) { \
         canary = GET_SP(); \
         SET_SV(vm_stack_canary); \
     } \
     else {\
         SET_SV(Qfalse); /* cleanup */ \
     }
-#define CHECK_CANARY() \
-    if (leaf) { \
+#define CHECK_CANARY(cond, insn) \
+    if (cond) { \
         if (*canary == vm_stack_canary) { \
             *canary = Qfalse; /* cleanup */ \
         } \
         else { \
-            vm_canary_is_found_dead(INSN_ATTR(bin), *canary); \
+            rb_vm_canary_is_found_dead(insn, *canary); \
         } \
     }
 #else
-#define SETUP_CANARY()          /* void */
-#define CHECK_CANARY()          /* void */
+#define SETUP_CANARY(cond)       if (cond) {} else {}
+#define CHECK_CANARY(cond, insn) if (cond) {(void)(insn);}
 #endif
 
 /**********************************************************/
@@ -173,11 +181,12 @@ enum vm_regan_acttype {
 } while (0)
 #endif
 
+#define PREV_CLASS_SERIAL() (ruby_vm_class_serial)
 #define NEXT_CLASS_SERIAL() (++ruby_vm_class_serial)
-#define GET_GLOBAL_METHOD_STATE() (ruby_vm_global_method_state)
-#define INC_GLOBAL_METHOD_STATE() (++ruby_vm_global_method_state)
 #define GET_GLOBAL_CONSTANT_STATE() (ruby_vm_global_constant_state)
 #define INC_GLOBAL_CONSTANT_STATE() (++ruby_vm_global_constant_state)
+#define GET_GLOBAL_CVAR_STATE() (ruby_vm_global_cvar_state)
+#define INC_GLOBAL_CVAR_STATE() (++ruby_vm_global_cvar_state)
 
 static inline struct vm_throw_data *
 THROW_DATA_NEW(VALUE val, const rb_control_frame_t *cf, int st)
@@ -233,23 +242,24 @@ static inline void
 THROW_DATA_CONSUMED_SET(struct vm_throw_data *obj)
 {
     if (THROW_DATA_P(obj) &&
-   THROW_DATA_STATE(obj) == TAG_BREAK) {
-   obj->flags |= THROW_DATA_CONSUMED;
+	THROW_DATA_STATE(obj) == TAG_BREAK) {
+	obj->flags |= THROW_DATA_CONSUMED;
     }
 }
 
-#define IS_ARGS_SPLAT(ci)   ((ci)->flag & VM_CALL_ARGS_SPLAT)
-#define IS_ARGS_KEYWORD(ci) ((ci)->flag & VM_CALL_KWARG)
-#define IS_ARGS_KW_SPLAT(ci) ((ci)->flag & VM_CALL_KW_SPLAT)
-#define IS_ARGS_KW_OR_KW_SPLAT(ci) ((ci)->flag & (VM_CALL_KWARG | VM_CALL_KW_SPLAT))
+#define IS_ARGS_SPLAT(ci)          (vm_ci_flag(ci) & VM_CALL_ARGS_SPLAT)
+#define IS_ARGS_KEYWORD(ci)        (vm_ci_flag(ci) & VM_CALL_KWARG)
+#define IS_ARGS_KW_SPLAT(ci)       (vm_ci_flag(ci) & VM_CALL_KW_SPLAT)
+#define IS_ARGS_KW_OR_KW_SPLAT(ci) (vm_ci_flag(ci) & (VM_CALL_KWARG | VM_CALL_KW_SPLAT))
+#define IS_ARGS_KW_SPLAT_MUT(ci)   (vm_ci_flag(ci) & VM_CALL_KW_SPLAT_MUT)
 
 /* If this returns true, an optimized function returned by `vm_call_iseq_setup_func`
    can be used as a fastpath. */
-static bool
-vm_call_iseq_optimizable_p(const struct rb_call_info *ci, const struct rb_call_cache *cc)
+static inline bool
+vm_call_iseq_optimizable_p(const struct rb_callinfo *ci, const struct rb_callcache *cc)
 {
     return !IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&
-        !(METHOD_ENTRY_VISI(cc->me) == METHOD_VISI_PROTECTED);
+        METHOD_ENTRY_CACHEABLE(vm_cc_cme(cc));
 }
 
 #endif /* RUBY_INSNHELPER_H */

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.1.0-preview1}/vm_opts.h

@@ -1,4 +1,5 @@
-/*-*-c-*-*/
+#ifndef RUBY_VM_OPTS_H/*-*-c-*-*/
+#define RUBY_VM_OPTS_H
 /**********************************************************************
 
   vm_opts.h - VM optimize option
@@ -9,10 +10,6 @@
 
 **********************************************************************/
 
-
-#ifndef RUBY_VM_OPTS_H
-#define RUBY_VM_OPTS_H
-
 /* Compile options.
  * You can change these options at runtime by VM::CompileOption.
  * Following definitions are default values.
@@ -61,7 +58,13 @@
 #define OPT_STACK_CACHING            0
 
 /* misc */
+#ifndef OPT_SUPPORT_JOKE
 #define OPT_SUPPORT_JOKE             0
+#endif
+
+#ifndef OPT_SUPPORT_CALL_C_FUNCTION
+#define OPT_SUPPORT_CALL_C_FUNCTION  0
+#endif
 
 #ifndef VM_COLLECT_USAGE_DETAILS
 #define VM_COLLECT_USAGE_DETAILS     0

data/lib/debase/ruby_core_source/ruby-3.1.0-preview1/vm_sync.h

@@ -0,0 +1,137 @@
+#ifndef RUBY_VM_SYNC_H
+#define RUBY_VM_SYNC_H
+
+#include "vm_debug.h"
+#include "debug_counter.h"
+
+#if USE_RUBY_DEBUG_LOG
+#define LOCATION_ARGS const char *file, int line
+#define LOCATION_PARAMS file, line
+#define APPEND_LOCATION_ARGS , const char *file, int line
+#define APPEND_LOCATION_PARAMS , file, line
+#else
+#define LOCATION_ARGS void
+#define LOCATION_PARAMS
+#define APPEND_LOCATION_ARGS
+#define APPEND_LOCATION_PARAMS
+#endif
+
+bool rb_vm_locked_p(void);
+void rb_vm_lock_body(LOCATION_ARGS);
+void rb_vm_unlock_body(LOCATION_ARGS);
+
+struct rb_ractor_struct;
+void rb_vm_lock_enter_body_cr(struct rb_ractor_struct *cr, unsigned int *lev APPEND_LOCATION_ARGS);
+void rb_vm_lock_enter_body_nb(unsigned int *lev APPEND_LOCATION_ARGS);
+void rb_vm_lock_enter_body(unsigned int *lev APPEND_LOCATION_ARGS);
+void rb_vm_lock_leave_body(unsigned int *lev APPEND_LOCATION_ARGS);
+void rb_vm_barrier(void);
+
+#if RUBY_DEBUG
+// GET_VM()
+#include "vm_core.h"
+#endif
+
+RUBY_EXTERN struct rb_ractor_struct *ruby_single_main_ractor; // ractor.c
+
+static inline bool
+rb_multi_ractor_p(void)
+{
+    if (LIKELY(ruby_single_main_ractor)) {
+        // 0 on boot time.
+        RUBY_ASSERT(GET_VM()->ractor.cnt <= 1);
+        return false;
+    }
+    else {
+        // multi-ractor mode can run ractor.cnt == 1
+        return true;
+    }
+}
+
+static inline void
+rb_vm_lock(const char *file, int line)
+{
+    RB_DEBUG_COUNTER_INC(vm_sync_lock);
+
+    if (rb_multi_ractor_p()) {
+        rb_vm_lock_body(LOCATION_PARAMS);
+    }
+}
+
+static inline void
+rb_vm_unlock(const char *file, int line)
+{
+    if (rb_multi_ractor_p()) {
+        rb_vm_unlock_body(LOCATION_PARAMS);
+    }
+}
+
+static inline void
+rb_vm_lock_enter(unsigned int *lev, const char *file, int line)
+{
+    RB_DEBUG_COUNTER_INC(vm_sync_lock_enter);
+
+    if (rb_multi_ractor_p()) {
+        rb_vm_lock_enter_body(lev APPEND_LOCATION_PARAMS);
+    }
+}
+
+static inline void
+rb_vm_lock_enter_nb(unsigned int *lev, const char *file, int line)
+{
+    RB_DEBUG_COUNTER_INC(vm_sync_lock_enter_nb);
+
+    if (rb_multi_ractor_p()) {
+        rb_vm_lock_enter_body_nb(lev APPEND_LOCATION_PARAMS);
+    }
+}
+
+static inline void
+rb_vm_lock_leave(unsigned int *lev, const char *file, int line)
+{
+    if (rb_multi_ractor_p()) {
+        rb_vm_lock_leave_body(lev APPEND_LOCATION_PARAMS);
+    }
+}
+
+static inline void
+rb_vm_lock_enter_cr(struct rb_ractor_struct *cr, unsigned int *levp, const char *file, int line)
+{
+    RB_DEBUG_COUNTER_INC(vm_sync_lock_enter_cr);
+    rb_vm_lock_enter_body_cr(cr, levp APPEND_LOCATION_PARAMS);
+}
+
+static inline void
+rb_vm_lock_leave_cr(struct rb_ractor_struct *cr, unsigned int *levp, const char *file, int line)
+{
+    rb_vm_lock_leave_body(levp APPEND_LOCATION_PARAMS);
+}
+
+#define RB_VM_LOCKED_P()   rb_vm_locked_p()
+
+#define RB_VM_LOCK()       rb_vm_lock(__FILE__, __LINE__)
+#define RB_VM_UNLOCK()     rb_vm_unlock(__FILE__, __LINE__)
+
+#define RB_VM_LOCK_ENTER_CR_LEV(cr, levp) rb_vm_lock_enter_cr(cr, levp, __FILE__, __LINE__)
+#define RB_VM_LOCK_LEAVE_CR_LEV(cr, levp) rb_vm_lock_leave_cr(cr, levp, __FILE__, __LINE__)
+#define RB_VM_LOCK_ENTER_LEV(levp) rb_vm_lock_enter(levp, __FILE__, __LINE__)
+#define RB_VM_LOCK_LEAVE_LEV(levp) rb_vm_lock_leave(levp, __FILE__, __LINE__)
+
+#define RB_VM_LOCK_ENTER()  { unsigned int _lev; RB_VM_LOCK_ENTER_LEV(&_lev);
+#define RB_VM_LOCK_LEAVE()    RB_VM_LOCK_LEAVE_LEV(&_lev); }
+
+#define RB_VM_LOCK_ENTER_LEV_NB(levp) rb_vm_lock_enter_nb(levp, __FILE__, __LINE__)
+#define RB_VM_LOCK_ENTER_NO_BARRIER()  { unsigned int _lev; RB_VM_LOCK_ENTER_LEV_NB(&_lev);
+#define RB_VM_LOCK_LEAVE_NO_BARRIER()    RB_VM_LOCK_LEAVE_LEV(&_lev); }
+
+#if RUBY_DEBUG > 0
+void RUBY_ASSERT_vm_locking(void);
+void RUBY_ASSERT_vm_unlocking(void);
+#define ASSERT_vm_locking() RUBY_ASSERT_vm_locking()
+#define ASSERT_vm_unlocking() RUBY_ASSERT_vm_unlocking()
+#else
+#define ASSERT_vm_locking()
+#define ASSERT_vm_unlocking()
+#endif
+
+#endif // RUBY_VM_SYNC_H

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.1.0-preview1}/vmtc.inc

@@ -59,7 +59,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(putstring),
     LABEL_PTR(concatstrings),
     LABEL_PTR(tostring),
-    LABEL_PTR(freezestring),
     LABEL_PTR(toregexp),
     LABEL_PTR(intern),
     LABEL_PTR(newarray),
@@ -75,7 +74,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(dup),
     LABEL_PTR(dupn),
     LABEL_PTR(swap),
-    LABEL_PTR(reverse),
     LABEL_PTR(topn),
     LABEL_PTR(setn),
     LABEL_PTR(adjuststack),
@@ -83,7 +81,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(checkmatch),
     LABEL_PTR(checkkeyword),
     LABEL_PTR(checktype),
-    LABEL_PTR(methodref),
     LABEL_PTR(defineclass),
     LABEL_PTR(definemethod),
     LABEL_PTR(definesmethod),
@@ -130,7 +127,9 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(opt_succ),
     LABEL_PTR(opt_not),
     LABEL_PTR(opt_regexpmatch2),
-    LABEL_PTR(opt_call_c_function),
+    LABEL_PTR(invokebuiltin),
+    LABEL_PTR(opt_invokebuiltin_delegate),
+    LABEL_PTR(opt_invokebuiltin_delegate_leave),
     LABEL_PTR(getlocal_WC_0),
     LABEL_PTR(getlocal_WC_1),
     LABEL_PTR(setlocal_WC_0),
@@ -160,7 +159,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_putstring),
     LABEL_PTR(trace_concatstrings),
     LABEL_PTR(trace_tostring),
-    LABEL_PTR(trace_freezestring),
     LABEL_PTR(trace_toregexp),
     LABEL_PTR(trace_intern),
     LABEL_PTR(trace_newarray),
@@ -176,7 +174,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_dup),
     LABEL_PTR(trace_dupn),
     LABEL_PTR(trace_swap),
-    LABEL_PTR(trace_reverse),
     LABEL_PTR(trace_topn),
     LABEL_PTR(trace_setn),
     LABEL_PTR(trace_adjuststack),
@@ -184,7 +181,6 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_checkmatch),
     LABEL_PTR(trace_checkkeyword),
     LABEL_PTR(trace_checktype),
-    LABEL_PTR(trace_methodref),
     LABEL_PTR(trace_defineclass),
     LABEL_PTR(trace_definemethod),
     LABEL_PTR(trace_definesmethod),
@@ -231,7 +227,9 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_opt_succ),
     LABEL_PTR(trace_opt_not),
     LABEL_PTR(trace_opt_regexpmatch2),
-    LABEL_PTR(trace_opt_call_c_function),
+    LABEL_PTR(trace_invokebuiltin),
+    LABEL_PTR(trace_opt_invokebuiltin_delegate),
+    LABEL_PTR(trace_opt_invokebuiltin_delegate_leave),
     LABEL_PTR(trace_getlocal_WC_0),
     LABEL_PTR(trace_getlocal_WC_1),
     LABEL_PTR(trace_setlocal_WC_0),

data/lib/debase/ruby_core_source/ruby-3.1.0-preview1/yjit.h

@@ -0,0 +1,63 @@
+#ifndef YJIT_H
+#define YJIT_H 1
+//
+// This file contains definitions YJIT exposes to the CRuby codebase
+//
+
+#include "ruby/internal/config.h"
+#include "ruby_assert.h" // for RUBY_DEBUG
+#include "vm_core.h"
+#include "method.h"
+
+// YJIT_STATS controls whether to support runtime counters in generated code
+// and in the interpreter.
+#ifndef YJIT_STATS
+# define YJIT_STATS RUBY_DEBUG
+#endif
+
+struct rb_yjit_options {
+    // Enable compilation with YJIT
+    bool yjit_enabled;
+
+    // Size of the executable memory block to allocate in MiB
+    unsigned exec_mem_size;
+
+    // Number of method calls after which to start generating code
+    // Threshold==1 means compile on first execution
+    unsigned call_threshold;
+
+    // Generate versions greedily until the limit is hit
+    bool greedy_versioning;
+
+    // Maximum number of versions per block
+    // 1 means always create generic versions
+    unsigned max_versions;
+
+    // Capture and print out stats
+    bool gen_stats;
+
+    // Run backend tests
+    bool test_backend;
+};
+
+bool rb_yjit_enabled_p(void);
+unsigned rb_yjit_call_threshold(void);
+
+void rb_yjit_invalidate_all_method_lookup_assumptions(void);
+void rb_yjit_method_lookup_change(VALUE klass, ID mid);
+void rb_yjit_cme_invalidate(VALUE cme);
+void rb_yjit_collect_vm_usage_insn(int insn);
+void rb_yjit_collect_binding_alloc(void);
+void rb_yjit_collect_binding_set(void);
+bool rb_yjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec);
+void rb_yjit_init(struct rb_yjit_options *options);
+void rb_yjit_bop_redefined(VALUE klass, const rb_method_entry_t *me, enum ruby_basic_operators bop);
+void rb_yjit_constant_state_changed(void);
+void rb_yjit_iseq_mark(const struct rb_iseq_constant_body *body);
+void rb_yjit_iseq_update_references(const struct rb_iseq_constant_body *body);
+void rb_yjit_iseq_free(const struct rb_iseq_constant_body *body);
+void rb_yjit_before_ractor_spawn(void);
+void rb_yjit_constant_ic_update(const rb_iseq_t *iseq, IC ic);
+void rb_yjit_tracing_invalidate_all(void);
+
+#endif // #ifndef YJIT_H