debase-ruby_core_source 3.3.5 → 3.3.6

data/lib/debase/ruby_core_source/ruby-3.4.0-preview2/vm_debug.h

@@ -0,0 +1,124 @@
+#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"
+
+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))
+
+struct RNode;
+
+VALUE ruby_debug_print_value(int level, int debug_level, const char *header, VALUE v);
+void  ruby_debug_print_v(VALUE v);
+ID    ruby_debug_print_id(int level, int debug_level, const char *header, ID id);
+struct RNode *ruby_debug_print_node(int level, int debug_level, const char *header, const struct RNode *node);
+void  ruby_debug_print_n(const struct RNode *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
+
+#ifndef USE_RUBY_DEBUG_LOG
+#define USE_RUBY_DEBUG_LOG 0
+#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, const char *file_name);
+
+#if RBIMPL_COMPILER_IS(GCC) && defined(__OPTIMIZE__)
+# define ruby_debug_log(...) \
+    RB_GNUC_EXTENSION_BLOCK( \
+        RBIMPL_WARNING_PUSH(); \
+        RBIMPL_WARNING_IGNORED(-Wformat-zero-length); \
+        ruby_debug_log(__VA_ARGS__); \
+        RBIMPL_WARNING_POP())
+#endif
+
+// 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, file_name)                     \
+    (ruby_debug_log_mode && ruby_debug_log_filter(func_name, file_name))
+
+#define RUBY_DEBUG_LOG(...) do { \
+    if (RUBY_DEBUG_LOG_ENABLED(RUBY_FUNCTION_NAME_STRING, __FILE__)) \
+        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, file)) \
+        ruby_debug_log(file, line, RUBY_FUNCTION_NAME_STRING, "" __VA_ARGS__); \
+} while (0)
+
+#else // USE_RUBY_DEBUG_LOG
+// 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-3.4.0-preview2/vm_exec.h

@@ -0,0 +1,199 @@
+#ifndef RUBY_VM_EXEC_H
+#define RUBY_VM_EXEC_H
+/**********************************************************************
+
+  vm.h -
+
+  $Author$
+  created at: 04/01/01 16:56:59 JST
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+typedef long OFFSET;
+typedef unsigned long lindex_t;
+typedef VALUE GENTRY;
+typedef rb_iseq_t *ISEQ;
+
+#if VMDEBUG > 0
+#define debugs printf
+#define DEBUG_ENTER_INSN(insn) \
+    rb_vmdebug_debug_print_pre(ec, GET_CFP(), GET_PC());
+
+#define SC_REGS()
+
+#define DEBUG_END_INSN() \
+  rb_vmdebug_debug_print_post(ec, GET_CFP() SC_REGS());
+
+#else
+
+#define debugs
+#define DEBUG_ENTER_INSN(insn)
+#define DEBUG_END_INSN()
+#endif
+
+#define throwdebug if(0)ruby_debug_printf
+/* #define throwdebug ruby_debug_printf */
+
+/************************************************/
+#if defined(DISPATCH_XXX)
+error !
+/************************************************/
+#elif OPT_CALL_THREADED_CODE
+
+#define LABEL(x)  insn_func_##x
+#define ELABEL(x)
+#define LABEL_PTR(x) &LABEL(x)
+
+#define INSN_ENTRY(insn) \
+  static rb_control_frame_t * \
+    FUNC_FASTCALL(LABEL(insn))(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp) {
+
+#define END_INSN(insn) return reg_cfp;}
+
+#define NEXT_INSN() return reg_cfp;
+
+#define START_OF_ORIGINAL_INSN(x) /* ignore */
+#define DISPATCH_ORIGINAL_INSN(x) return LABEL(x)(ec, reg_cfp);
+
+/************************************************/
+#elif OPT_TOKEN_THREADED_CODE || OPT_DIRECT_THREADED_CODE
+/* threaded code with gcc */
+
+#define LABEL(x)  INSN_LABEL_##x
+#define ELABEL(x) INSN_ELABEL_##x
+#define LABEL_PTR(x) RB_GNUC_EXTENSION(&&LABEL(x))
+
+#define INSN_ENTRY_SIG(insn) \
+  if (0) { \
+      ruby_debug_printf("exec: %s@(%"PRIdPTRDIFF", %"PRIdPTRDIFF")@%s:%u\n", #insn, \
+                        (reg_pc - ISEQ_BODY(reg_cfp->iseq)->iseq_encoded), \
+                        (reg_cfp->pc - ISEQ_BODY(reg_cfp->iseq)->iseq_encoded), \
+                        RSTRING_PTR(rb_iseq_path(reg_cfp->iseq)), \
+                        rb_iseq_line_no(reg_cfp->iseq, reg_pc - ISEQ_BODY(reg_cfp->iseq)->iseq_encoded)); \
+  }
+
+#define INSN_DISPATCH_SIG(insn)
+
+#define INSN_ENTRY(insn) \
+  LABEL(insn): \
+  INSN_ENTRY_SIG(insn); \
+
+/**********************************/
+#if OPT_DIRECT_THREADED_CODE
+
+/* for GCC 3.4.x */
+#define TC_DISPATCH(insn) \
+  INSN_DISPATCH_SIG(insn); \
+  RB_GNUC_EXTENSION_BLOCK(goto *(void const *)GET_CURRENT_INSN()); \
+  ;
+
+#else
+/* token threaded code */
+
+/* dispatcher */
+#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && __GNUC__ == 3
+#define DISPATCH_ARCH_DEPEND_WAY(addr) \
+  __asm__ __volatile__("jmp *%0;\t# -- inserted by vm.h\t[length = 2]" : : "r" (addr))
+
+#else
+#define DISPATCH_ARCH_DEPEND_WAY(addr) \
+                                /* do nothing */
+#endif
+#define TC_DISPATCH(insn)  \
+  DISPATCH_ARCH_DEPEND_WAY(insns_address_table[GET_CURRENT_INSN()]); \
+  INSN_DISPATCH_SIG(insn); \
+  RB_GNUC_EXTENSION_BLOCK(goto *insns_address_table[GET_CURRENT_INSN()]); \
+  rb_bug("tc error");
+
+#endif /* OPT_DIRECT_THREADED_CODE */
+
+#define END_INSN(insn)      \
+  DEBUG_END_INSN();         \
+  TC_DISPATCH(insn);
+
+#define INSN_DISPATCH()     \
+  TC_DISPATCH(__START__)    \
+  {
+
+#define END_INSNS_DISPATCH()    \
+      rb_bug("unknown insn: %"PRIdVALUE, GET_CURRENT_INSN());   \
+  }   /* end of while loop */   \
+
+#define NEXT_INSN() TC_DISPATCH(__NEXT_INSN__)
+
+/************************************************/
+#else /* no threaded code */
+/* most common method */
+
+#define INSN_ENTRY(insn) \
+case BIN(insn):
+
+#define END_INSN(insn)                        \
+  DEBUG_END_INSN();                           \
+  break;
+
+#define INSN_DISPATCH()         \
+  while (1) {			\
+    switch (GET_CURRENT_INSN()) {
+
+#define END_INSNS_DISPATCH()    \
+default:                        \
+  SDR(); \
+      rb_bug("unknown insn: %ld", GET_CURRENT_INSN());   \
+    } /* end of switch */       \
+  }   /* end of while loop */   \
+
+#define NEXT_INSN() goto first
+
+#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)
+
+#if OPT_CALL_THREADED_CODE
+#define THROW_EXCEPTION(exc) do { \
+    ec->errinfo = (VALUE)(exc); \
+    return 0; \
+} while (0)
+#else
+#define THROW_EXCEPTION(exc) return (VALUE)(exc)
+#endif
+
+// Run the interpreter from the JIT
+#define VM_EXEC(ec, val) do { \
+    if (UNDEF_P(val)) { \
+        VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH); \
+        val = vm_exec(ec); \
+    } \
+} while (0)
+
+// Run the JIT from the interpreter
+#define JIT_EXEC(ec, val) do { \
+    rb_jit_func_t func; \
+    /* don't run tailcalls since that breaks FINISH */ \
+    if (UNDEF_P(val) && GET_CFP() != ec->cfp && (func = jit_compile(ec))) { \
+        val = func(ec, ec->cfp); \
+        if (ec->tag->state) THROW_EXCEPTION(val); \
+    } \
+} while (0)
+
+#define SCREG(r) (reg_##r)
+
+#define VM_DEBUG_STACKOVERFLOW 0
+
+#if VM_DEBUG_STACKOVERFLOW
+#define CHECK_VM_STACK_OVERFLOW_FOR_INSN CHECK_VM_STACK_OVERFLOW
+#else
+#define CHECK_VM_STACK_OVERFLOW_FOR_INSN(cfp, margin)
+#endif
+
+#define INSN_LABEL2(insn, name) INSN_LABEL_ ## insn ## _ ## name
+#define INSN_LABEL(x) INSN_LABEL2(NAME_OF_CURRENT_INSN, x)
+
+#endif /* RUBY_VM_EXEC_H */

data/lib/debase/ruby_core_source/ruby-3.4.0-preview2/vm_insnhelper.h

@@ -0,0 +1,277 @@
+#ifndef RUBY_INSNHELPER_H
+#define RUBY_INSNHELPER_H
+/**********************************************************************
+
+  insnhelper.h - helper macros to implement each instructions
+
+  $Author$
+  created at: 04/01/01 15:50:34 JST
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+RUBY_EXTERN VALUE ruby_vm_const_missing_count;
+RUBY_EXTERN rb_serial_t ruby_vm_constant_cache_invalidations;
+RUBY_EXTERN rb_serial_t ruby_vm_constant_cache_misses;
+RUBY_EXTERN rb_serial_t ruby_vm_global_cvar_state;
+
+#if USE_YJIT || USE_RJIT // We want vm_insns_count on any JIT-enabled build.
+// Increment vm_insns_count for --yjit-stats. We increment this even when
+// --yjit or --yjit-stats is not used because branching to skip it is slower.
+// We also don't use ATOMIC_INC for performance, allowing inaccuracy on Ractors.
+#define JIT_COLLECT_USAGE_INSN(insn) rb_vm_insns_count++
+#else
+#define JIT_COLLECT_USAGE_INSN(insn) // none
+#endif
+
+#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))
+#else
+#define COLLECT_USAGE_INSN(insn)           JIT_COLLECT_USAGE_INSN(insn)
+#define COLLECT_USAGE_OPERAND(insn, n, op) // none
+#define COLLECT_USAGE_REGISTER(reg, s)     // none
+#endif
+
+/**********************************************************/
+/* deal with stack                                        */
+/**********************************************************/
+
+#define PUSH(x) (SET_SV(x), INC_SP(1))
+#define TOPN(n) (*(GET_SP()-(n)-1))
+#define POPN(n) (DEC_SP(n))
+#define POP()   (DEC_SP(1))
+#define STACK_ADDR_FROM_TOP(n) (GET_SP()-(n))
+
+/**********************************************************/
+/* deal with registers                                    */
+/**********************************************************/
+
+#define VM_REG_CFP (reg_cfp)
+#define VM_REG_PC  (VM_REG_CFP->pc)
+#define VM_REG_SP  (VM_REG_CFP->sp)
+#define VM_REG_EP  (VM_REG_CFP->ep)
+
+#define RESTORE_REGS() do { \
+    VM_REG_CFP = ec->cfp; \
+} while (0)
+
+typedef enum call_type {
+    CALL_PUBLIC,
+    CALL_FCALL,
+    CALL_VCALL,
+    CALL_PUBLIC_KW,
+    CALL_FCALL_KW
+} call_type;
+
+struct rb_forwarding_call_data {
+    struct rb_call_data cd;
+    CALL_INFO caller_ci;
+};
+
+#if VM_COLLECT_USAGE_DETAILS
+enum vm_regan_regtype {
+    VM_REGAN_PC = 0,
+    VM_REGAN_SP = 1,
+    VM_REGAN_EP = 2,
+    VM_REGAN_CFP = 3,
+    VM_REGAN_SELF = 4,
+    VM_REGAN_ISEQ = 5
+};
+enum vm_regan_acttype {
+    VM_REGAN_ACT_GET = 0,
+    VM_REGAN_ACT_SET = 1
+};
+
+#define COLLECT_USAGE_REGISTER_HELPER(a, b, v) \
+  (COLLECT_USAGE_REGISTER((VM_REGAN_##a), (VM_REGAN_ACT_##b)), (v))
+#else
+#define COLLECT_USAGE_REGISTER_HELPER(a, b, v) (v)
+#endif
+
+/* PC */
+#define GET_PC()           (COLLECT_USAGE_REGISTER_HELPER(PC, GET, VM_REG_PC))
+#define SET_PC(x)          (VM_REG_PC = (COLLECT_USAGE_REGISTER_HELPER(PC, SET, (x))))
+#define GET_CURRENT_INSN() (*GET_PC())
+#define GET_OPERAND(n)     (GET_PC()[(n)])
+#define ADD_PC(n)          (SET_PC(VM_REG_PC + (n)))
+#define JUMP(dst)          (SET_PC(VM_REG_PC + (dst)))
+
+/* frame pointer, environment pointer */
+#define GET_CFP()  (COLLECT_USAGE_REGISTER_HELPER(CFP, GET, VM_REG_CFP))
+#define GET_EP()   (COLLECT_USAGE_REGISTER_HELPER(EP, GET, VM_REG_EP))
+#define SET_EP(x)  (VM_REG_EP = (COLLECT_USAGE_REGISTER_HELPER(EP, SET, (x))))
+#define GET_LEP()  (VM_EP_LEP(GET_EP()))
+
+/* SP */
+#define GET_SP()   (COLLECT_USAGE_REGISTER_HELPER(SP, GET, VM_REG_SP))
+#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() = rb_ractor_confirm_belonging(x))
+  /* set current stack value as x */
+
+/* instruction sequence C struct */
+#define GET_ISEQ() (GET_CFP()->iseq)
+
+/**********************************************************/
+/* deal with variables                                    */
+/**********************************************************/
+
+#define GET_PREV_EP(ep)                ((VALUE *)((ep)[VM_ENV_DATA_INDEX_SPECVAL] & ~0x03))
+
+/**********************************************************/
+/* deal with values                                       */
+/**********************************************************/
+
+#define GET_SELF() (COLLECT_USAGE_REGISTER_HELPER(SELF, GET, GET_CFP()->self))
+
+/**********************************************************/
+/* deal with control flow 2: method/iterator              */
+/**********************************************************/
+
+/* set fastpath when cached method is *NOT* protected
+ * because inline method cache does not care about receiver.
+ */
+
+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])
+
+/**********************************************************/
+/* deal with control flow 3: exception                    */
+/**********************************************************/
+
+
+/**********************************************************/
+/* deal with stack canary                                 */
+/**********************************************************/
+
+#if VM_CHECK_MODE > 0
+#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(cond, insn) \
+    if (cond) { \
+        if (*canary == vm_stack_canary) { \
+            *canary = Qfalse; /* cleanup */ \
+        } \
+        else { \
+            rb_vm_canary_is_found_dead(insn, *canary); \
+        } \
+    }
+#else
+#define SETUP_CANARY(cond)       if (cond) {} else {}
+#define CHECK_CANARY(cond, insn) if (cond) {(void)(insn);}
+#endif
+
+/**********************************************************/
+/* others                                                 */
+/**********************************************************/
+
+#define CALL_SIMPLE_METHOD() do { \
+    rb_snum_t insn_width = attr_width_opt_send_without_block(0); \
+    ADD_PC(-insn_width); \
+    DISPATCH_ORIGINAL_INSN(opt_send_without_block); \
+} while (0)
+
+#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)
+{
+    struct vm_throw_data *obj = IMEMO_NEW(struct vm_throw_data, imemo_throw_data, 0);
+    *((VALUE *)&obj->throw_obj) = val;
+    *((struct rb_control_frame_struct **)&obj->catch_frame) = (struct rb_control_frame_struct *)cf;
+    obj->throw_state = st;
+
+    return obj;
+}
+
+static inline VALUE
+THROW_DATA_VAL(const struct vm_throw_data *obj)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    return obj->throw_obj;
+}
+
+static inline const rb_control_frame_t *
+THROW_DATA_CATCH_FRAME(const struct vm_throw_data *obj)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    return obj->catch_frame;
+}
+
+static inline int
+THROW_DATA_STATE(const struct vm_throw_data *obj)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    return obj->throw_state;
+}
+
+static inline int
+THROW_DATA_CONSUMED_P(const struct vm_throw_data *obj)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    return obj->flags & THROW_DATA_CONSUMED;
+}
+
+static inline void
+THROW_DATA_CATCH_FRAME_SET(struct vm_throw_data *obj, const rb_control_frame_t *cfp)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    obj->catch_frame = cfp;
+}
+
+static inline void
+THROW_DATA_STATE_SET(struct vm_throw_data *obj, int st)
+{
+    VM_ASSERT(THROW_DATA_P(obj));
+    obj->throw_state = st;
+}
+
+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;
+    }
+}
+
+#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)
+
+static inline bool
+vm_call_cacheable(const struct rb_callinfo *ci, const struct rb_callcache *cc)
+{
+    return !(vm_ci_flag(ci) & VM_CALL_FORWARDING) && ((vm_ci_flag(ci) & VM_CALL_FCALL) ||
+        METHOD_ENTRY_VISI(vm_cc_cme(cc)) != METHOD_VISI_PROTECTED);
+}
+/* If this returns true, an optimized function returned by `vm_call_iseq_setup_func`
+   can be used as a fastpath. */
+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) && vm_call_cacheable(ci, cc);
+}
+
+#endif /* RUBY_INSNHELPER_H */

data/lib/debase/ruby_core_source/ruby-3.4.0-preview2/vm_opts.h

@@ -0,0 +1,67 @@
+#ifndef RUBY_VM_OPTS_H/*-*-c-*-*/
+#define RUBY_VM_OPTS_H
+/**********************************************************************
+
+  vm_opts.h - VM optimize option
+
+  $Author$
+
+  Copyright (C) 2004-2007 Koichi Sasada
+
+**********************************************************************/
+
+/* Compile options.
+ * You can change these options at runtime by VM::CompileOption.
+ * Following definitions are default values.
+ */
+
+#define OPT_TAILCALL_OPTIMIZATION       0
+#define OPT_PEEPHOLE_OPTIMIZATION       1
+#define OPT_SPECIALISED_INSTRUCTION     1
+#define OPT_INLINE_CONST_CACHE          1
+#define OPT_FROZEN_STRING_LITERAL       -1
+#define OPT_DEBUG_FROZEN_STRING_LITERAL 0
+
+/* Build Options.
+ * You can't change these options at runtime.
+ */
+
+/* C compiler dependent */
+
+/*
+ * 0: direct (using labeled goto using GCC special)
+ * 1: token (switch/case)
+ * 2: call (function call for each insn dispatch)
+ */
+#ifndef OPT_THREADED_CODE
+#define OPT_THREADED_CODE 0
+#endif
+
+#define OPT_DIRECT_THREADED_CODE (OPT_THREADED_CODE == 0)
+#define OPT_TOKEN_THREADED_CODE  (OPT_THREADED_CODE == 1)
+#define OPT_CALL_THREADED_CODE   (OPT_THREADED_CODE == 2)
+
+/* VM running option */
+#define OPT_CHECKED_RUN              1
+#define OPT_INLINE_METHOD_CACHE      1
+#define OPT_GLOBAL_METHOD_CACHE      1
+
+#ifndef OPT_IC_FOR_IVAR
+#define OPT_IC_FOR_IVAR 1
+#endif
+
+/* architecture independent, affects generated code */
+#define OPT_OPERANDS_UNIFICATION     1
+#define OPT_INSTRUCTIONS_UNIFICATION 0
+#define OPT_UNIFY_ALL_COMBINATION    0
+
+/* misc */
+#ifndef OPT_SUPPORT_JOKE
+#define OPT_SUPPORT_JOKE             0
+#endif
+
+#ifndef VM_COLLECT_USAGE_DETAILS
+#define VM_COLLECT_USAGE_DETAILS     0
+#endif
+
+#endif /* RUBY_VM_OPTS_H */