debase-ruby_core_source 0.10.9 → 0.10.13

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/vm_debug.h

@@ -0,0 +1,116 @@
+#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;
+
+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(fmt, ...) ruby_debug_log(__FILE__, __LINE__, __func__, fmt, __VA_ARGS__)
+
+#if USE_RUBY_DEBUG_LOG
+
+#define RUBY_DEBUG_LOG(fmt, ...) do { \
+  if (ruby_debug_log_mode && ruby_debug_log_filter(__func__)) \
+    ruby_debug_log(__FILE__, __LINE__, __func__, fmt, __VA_ARGS__); \
+} while (0)
+
+#define RUBY_DEBUG_LOG2(file, line, fmt, ...) do { \
+  if (ruby_debug_log_mode && ruby_debug_log_filter(__func__)) \
+    ruby_debug_log(file, line, __func__, fmt, __VA_ARGS__); \
+} while (0)
+
+#else
+// do nothing
+#define RUBY_DEBUG_LOG(fmt, ...)
+#define RUBY_DEBUG_LOG2(file, line, fmt, ...)
+#endif // USE_RUBY_DEBUG_LOG
+
+#endif /* RUBY_DEBUG_H */

data/lib/debase/ruby_core_source/{ruby-2.7.0-preview2 → ruby-3.0.0-p0}/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;
@@ -41,6 +40,10 @@ typedef rb_iseq_t *ISEQ;
 #define throwdebug if(0)printf
 /* #define throwdebug printf */
 
+#ifndef USE_INSNS_COUNTER
+#define USE_INSNS_COUNTER 0
+#endif
+
 /************************************************/
 #if defined(DISPATCH_XXX)
 error !
@@ -75,7 +78,8 @@ error !
                  (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));
+                 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)
 
@@ -181,8 +185,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-preview2 → ruby-3.0.0-p0}/vm_insnhelper.h

@@ -1,3 +1,5 @@
+#ifndef RUBY_INSNHELPER_H
+#define RUBY_INSNHELPER_H
 /**********************************************************************
 
   insnhelper.h - helper macros to implement each instructions
@@ -9,13 +11,9 @@
 
 **********************************************************************/
 
-#ifndef RUBY_INSNHELPER_H
-#define RUBY_INSNHELPER_H
-
 RUBY_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;
 
@@ -94,7 +92,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 +118,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 +138,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); \
+            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
 
 /**********************************************************/
@@ -166,16 +168,15 @@ enum vm_regan_acttype {
 #ifndef MJIT_HEADER
 #define CALL_SIMPLE_METHOD() do { \
     rb_snum_t x = leaf ? INSN_ATTR(width) : 0; \
-    rb_snum_t y = attr_width_opt_send_without_block(0, 0); \
+    rb_snum_t y = attr_width_opt_send_without_block(0); \
     rb_snum_t z = x - y; \
     ADD_PC(z); \
     DISPATCH_ORIGINAL_INSN(opt_send_without_block); \
 } 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)
 
@@ -238,18 +239,19 @@ THROW_DATA_CONSUMED_SET(struct vm_throw_data *obj)
     }
 }
 
-#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-preview3 → ruby-3.0.0-p0}/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.
@@ -65,6 +62,10 @@
 #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
 #endif

data/lib/debase/ruby_core_source/ruby-3.0.0-p0/vm_sync.h

@@ -0,0 +1,136 @@
+
+#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 ASSERT_vm_locking(void);
+void ASSERT_vm_unlocking(void);
+#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-preview3 → ruby-3.0.0-p0}/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),
@@ -129,7 +128,6 @@ 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),
@@ -162,7 +160,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),
@@ -232,7 +229,6 @@ 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),

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

@@ -1,3 +1,5 @@
+#ifndef RUBY_ADDR2LINE_H
+#define RUBY_ADDR2LINE_H
 /**********************************************************************
 
   addr2line.h -
@@ -8,9 +10,6 @@
 
 **********************************************************************/
 
-#ifndef RUBY_ADDR2LINE_H
-#define RUBY_ADDR2LINE_H
-
 #if (defined(USE_ELF) || defined(HAVE_MACH_O_LOADER_H))
 
 void

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

@@ -0,0 +1,83 @@
+#ifndef BUILTIN_H_INCLUDED
+#define BUILTIN_H_INCLUDED
+
+// invoke
+
+struct rb_builtin_function {
+    // for invocation
+    const void * const func_ptr;
+    const int argc;
+
+    // for load
+    const int index;
+    const char * const name;
+
+    // for jit
+    void (*compiler)(FILE *, long, unsigned, bool);
+};
+
+#define RB_BUILTIN_FUNCTION(_i, _name, _fname, _arity, _compiler) {\
+  .name = #_name, \
+  .func_ptr = (void *)_fname, \
+  .argc = _arity, \
+  .index = _i, \
+  .compiler = _compiler, \
+}
+
+void rb_load_with_builtin_functions(const char *feature_name, const struct rb_builtin_function *table);
+
+#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
+
+/* The following code is generated by the following Ruby script:
+
+16.times{|i|
+  args = (i > 0 ? ', ' : '') + (0...i).map{"VALUE"}.join(', ')
+  puts "static inline void rb_builtin_function_check_arity#{i}(VALUE (*f)(rb_execution_context_t *ec, VALUE self#{args})){}"
+}
+*/
+
+static inline void rb_builtin_function_check_arity0(VALUE (*f)(rb_execution_context_t *ec, VALUE self)){}
+static inline void rb_builtin_function_check_arity1(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE)){}
+static inline void rb_builtin_function_check_arity2(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity3(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity4(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity5(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity6(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity7(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity8(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity9(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity10(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity11(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity12(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity13(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity14(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+static inline void rb_builtin_function_check_arity15(VALUE (*f)(rb_execution_context_t *ec, VALUE self, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE)){}
+
+VALUE rb_vm_lvar_exposed(rb_execution_context_t *ec, int index);
+
+// __builtin_inline!
+
+PUREFUNC(static inline VALUE rb_vm_lvar(rb_execution_context_t *ec, int index));
+
+static inline VALUE
+rb_vm_lvar(rb_execution_context_t *ec, int index)
+{
+#if defined(VM_CORE_H_EC_DEFINED) && VM_CORE_H_EC_DEFINED
+    return ec->cfp->ep[index];
+#else
+    return rb_vm_lvar_exposed(ec, index);
+#endif
+}
+
+// dump/load
+
+struct builtin_binary {
+    const char *feature;          // feature name
+    const unsigned char *bin;     // binary by ISeq#to_binary
+    size_t bin_size;
+};
+
+#endif // BUILTIN_H_INCLUDED

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

@@ -10,17 +10,17 @@
  * by the compiler.  This can only be used within a function.
  *
  * Example:
- * #include <stddef.h>
- * ...
- * static char *foo_to_char(struct foo *foo)
- * {
- *     // This code needs string to be at start of foo.
- *     BUILD_ASSERT(offsetof(struct foo, string) == 0);
- *     return (char *)foo;
- * }
+ *	#include <stddef.h>
+ *	...
+ *	static char *foo_to_char(struct foo *foo)
+ *	{
+ *		// This code needs string to be at start of foo.
+ *		BUILD_ASSERT(offsetof(struct foo, string) == 0);
+ *		return (char *)foo;
+ *	}
  */
 #define BUILD_ASSERT(cond) \
-   do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
+	do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
 
 /**
  * BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
@@ -30,11 +30,11 @@
  * by the compiler.  This can be used in an expression: its value is "0".
  *
  * Example:
- * #define foo_to_char(foo)                    \
- *      ((char *)(foo)                     \
- *       + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
+ *	#define foo_to_char(foo)					\
+ *		 ((char *)(foo)						\
+ *		  + BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
  */
 #define BUILD_ASSERT_OR_ZERO(cond) \
-   (sizeof(char [1 - 2*!(cond)]) - 1)
+	(sizeof(char [1 - 2*!(cond)]) - 1)
 
 #endif /* CCAN_BUILD_ASSERT_H */

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

@@ -17,9 +17,9 @@
  * to compile if the sizes of the types are unequal (a less complete check).
  *
  * Example:
- * // They should always pass a 64-bit value to _set_some_value!
- * #define set_some_value(expr)            \
- *     _set_some_value((check_type((expr), uint64_t), (expr)))
+ *	// They should always pass a 64-bit value to _set_some_value!
+ *	#define set_some_value(expr)			\
+ *		_set_some_value((check_type((expr), uint64_t), (expr)))
  */
 
 /**
@@ -37,27 +37,27 @@
  * to compile if the sizes of the types are unequal (a less complete check).
  *
  * Example:
- * // Do subtraction to get to enclosing type, but make sure that
- * // pointer is of correct type for that member.
- * #define container_of(mbr_ptr, encl_type, mbr)           \
- *     (check_types_match((mbr_ptr), &((encl_type *)0)->mbr),  \
- *      ((encl_type *)                     \
- *       ((char *)(mbr_ptr) - offsetof(enclosing_type, mbr))))
+ *	// Do subtraction to get to enclosing type, but make sure that
+ *	// pointer is of correct type for that member.
+ *	#define container_of(mbr_ptr, encl_type, mbr)			\
+ *		(check_types_match((mbr_ptr), &((encl_type *)0)->mbr),	\
+ *		 ((encl_type *)						\
+ *		  ((char *)(mbr_ptr) - offsetof(enclosing_type, mbr))))
  */
 #if HAVE_TYPEOF
-#define check_type(expr, type)         \
-   ((typeof(expr) *)0 != (type *)0)
+#define check_type(expr, type)			\
+	((typeof(expr) *)0 != (type *)0)
 
-#define check_types_match(expr1, expr2)        \
-   ((typeof(expr1) *)0 != (typeof(expr2) *)0)
+#define check_types_match(expr1, expr2)		\
+	((typeof(expr1) *)0 != (typeof(expr2) *)0)
 #else
 #include "ccan/build_assert/build_assert.h"
 /* Without typeof, we can only test the sizes. */
-#define check_type(expr, type)                 \
-   BUILD_ASSERT_OR_ZERO(sizeof(expr) == sizeof(type))
+#define check_type(expr, type)					\
+	BUILD_ASSERT_OR_ZERO(sizeof(expr) == sizeof(type))
 
-#define check_types_match(expr1, expr2)                \
-   BUILD_ASSERT_OR_ZERO(sizeof(expr1) == sizeof(expr2))
+#define check_types_match(expr1, expr2)				\
+	BUILD_ASSERT_OR_ZERO(sizeof(expr1) == sizeof(expr2))
 #endif /* HAVE_TYPEOF */
 
 #endif /* CCAN_CHECK_TYPE_H */