debase-ruby_core_source 0.10.17 → 3.2.0

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

@@ -1,113 +0,0 @@
-#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);
-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);
-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);
-
-// 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 // 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.2.0-preview1/vm_insnhelper.h

@@ -1,262 +0,0 @@
-#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
-
-**********************************************************************/
-
-MJIT_SYMBOL_EXPORT_BEGIN
-
-RUBY_EXTERN VALUE ruby_vm_const_missing_count;
-RUBY_EXTERN rb_serial_t ruby_vm_class_serial;
-RUBY_EXTERN rb_serial_t ruby_vm_global_cvar_state;
-
-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 */
-#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)
-
-#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                                                 */
-/**********************************************************/
-
-#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); \
-    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_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 = (struct vm_throw_data *)rb_imemo_new(imemo_throw_data, val, (VALUE)cf, 0, 0);
-    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)
-
-/* 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) &&
-        METHOD_ENTRY_CACHEABLE(vm_cc_cme(cc));
-}
-
-#endif /* RUBY_INSNHELPER_H */

data/lib/debase/ruby_core_source/ruby-3.2.0-preview1/vmtc.inc

@@ -1,243 +0,0 @@
-/* -*- C -*- */
-
-/* This is  an auto-generated file  and is a  part of the  programming language
- * Ruby.   The person  who  created  a program  to  generate  this file  (``I''
- * hereafter) would like  to refrain from defining licensing  of this generated
- * source code.
- *
- * This file consists of many small  parts of codes copyrighted by each author,
- * not  only  the  ``I''  person.   Those  original  authors  agree  with  some
- * open-source license.  I  believe that the license we agree  is the condition
- * mentioned in  the file COPYING.  It  states "4.  You may  modify and include
- * the part of the software into any  other software ...".  But the problem is,
- * the license never makes it clear if  such modified parts still remain in the
- * same  license, or  not.   The fact  that  we agree  with  the source  code's
- * licensing terms does not automatically  define that of generated ones.  This
- * is the reason why this file is  under an unclear situation.  All what I know
- * is that above provision guarantees this file to exist.
- *
- * Please let me hesitate to declare  something about this nuanced contract.  I
- * am not in the position to take  over other authors' license to merge into my
- * one.  Changing them to (say) GPLv3 is not doable by myself.  Perhaps someday
- * it might turn  out to be okay to  say this file is under a  license.  I wish
- * the situation would become more clear in the future. */
-/*******************************************************************/
-/*******************************************************************/
-/*******************************************************************/
-/**
-  This file is for threaded code.
-
-  ----
-  This file is auto generated by insns2vm.rb
-  DO NOT TOUCH!
-
-  If you want to fix something, you must edit "tool/ruby_vm/views/vmtc.inc.erb"
-  or tool/insns2vm.rb
- */
-
-static const void *const insns_address_table[] = {
-    LABEL_PTR(nop),
-    LABEL_PTR(getlocal),
-    LABEL_PTR(setlocal),
-    LABEL_PTR(getblockparam),
-    LABEL_PTR(setblockparam),
-    LABEL_PTR(getblockparamproxy),
-    LABEL_PTR(getspecial),
-    LABEL_PTR(setspecial),
-    LABEL_PTR(getinstancevariable),
-    LABEL_PTR(setinstancevariable),
-    LABEL_PTR(getclassvariable),
-    LABEL_PTR(setclassvariable),
-    LABEL_PTR(getconstant),
-    LABEL_PTR(setconstant),
-    LABEL_PTR(getglobal),
-    LABEL_PTR(setglobal),
-    LABEL_PTR(putnil),
-    LABEL_PTR(putself),
-    LABEL_PTR(putobject),
-    LABEL_PTR(putspecialobject),
-    LABEL_PTR(putstring),
-    LABEL_PTR(concatstrings),
-    LABEL_PTR(anytostring),
-    LABEL_PTR(toregexp),
-    LABEL_PTR(intern),
-    LABEL_PTR(newarray),
-    LABEL_PTR(newarraykwsplat),
-    LABEL_PTR(duparray),
-    LABEL_PTR(duphash),
-    LABEL_PTR(expandarray),
-    LABEL_PTR(concatarray),
-    LABEL_PTR(splatarray),
-    LABEL_PTR(newhash),
-    LABEL_PTR(newrange),
-    LABEL_PTR(pop),
-    LABEL_PTR(dup),
-    LABEL_PTR(dupn),
-    LABEL_PTR(swap),
-    LABEL_PTR(topn),
-    LABEL_PTR(setn),
-    LABEL_PTR(adjuststack),
-    LABEL_PTR(defined),
-    LABEL_PTR(checkmatch),
-    LABEL_PTR(checkkeyword),
-    LABEL_PTR(checktype),
-    LABEL_PTR(defineclass),
-    LABEL_PTR(definemethod),
-    LABEL_PTR(definesmethod),
-    LABEL_PTR(send),
-    LABEL_PTR(opt_send_without_block),
-    LABEL_PTR(objtostring),
-    LABEL_PTR(opt_str_freeze),
-    LABEL_PTR(opt_nil_p),
-    LABEL_PTR(opt_str_uminus),
-    LABEL_PTR(opt_newarray_max),
-    LABEL_PTR(opt_newarray_min),
-    LABEL_PTR(invokesuper),
-    LABEL_PTR(invokeblock),
-    LABEL_PTR(leave),
-    LABEL_PTR(throw),
-    LABEL_PTR(jump),
-    LABEL_PTR(branchif),
-    LABEL_PTR(branchunless),
-    LABEL_PTR(branchnil),
-    LABEL_PTR(opt_getinlinecache),
-    LABEL_PTR(opt_setinlinecache),
-    LABEL_PTR(once),
-    LABEL_PTR(opt_case_dispatch),
-    LABEL_PTR(opt_plus),
-    LABEL_PTR(opt_minus),
-    LABEL_PTR(opt_mult),
-    LABEL_PTR(opt_div),
-    LABEL_PTR(opt_mod),
-    LABEL_PTR(opt_eq),
-    LABEL_PTR(opt_neq),
-    LABEL_PTR(opt_lt),
-    LABEL_PTR(opt_le),
-    LABEL_PTR(opt_gt),
-    LABEL_PTR(opt_ge),
-    LABEL_PTR(opt_ltlt),
-    LABEL_PTR(opt_and),
-    LABEL_PTR(opt_or),
-    LABEL_PTR(opt_aref),
-    LABEL_PTR(opt_aset),
-    LABEL_PTR(opt_aset_with),
-    LABEL_PTR(opt_aref_with),
-    LABEL_PTR(opt_length),
-    LABEL_PTR(opt_size),
-    LABEL_PTR(opt_empty_p),
-    LABEL_PTR(opt_succ),
-    LABEL_PTR(opt_not),
-    LABEL_PTR(opt_regexpmatch2),
-    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),
-    LABEL_PTR(setlocal_WC_1),
-    LABEL_PTR(putobject_INT2FIX_0_),
-    LABEL_PTR(putobject_INT2FIX_1_),
-    LABEL_PTR(trace_nop),
-    LABEL_PTR(trace_getlocal),
-    LABEL_PTR(trace_setlocal),
-    LABEL_PTR(trace_getblockparam),
-    LABEL_PTR(trace_setblockparam),
-    LABEL_PTR(trace_getblockparamproxy),
-    LABEL_PTR(trace_getspecial),
-    LABEL_PTR(trace_setspecial),
-    LABEL_PTR(trace_getinstancevariable),
-    LABEL_PTR(trace_setinstancevariable),
-    LABEL_PTR(trace_getclassvariable),
-    LABEL_PTR(trace_setclassvariable),
-    LABEL_PTR(trace_getconstant),
-    LABEL_PTR(trace_setconstant),
-    LABEL_PTR(trace_getglobal),
-    LABEL_PTR(trace_setglobal),
-    LABEL_PTR(trace_putnil),
-    LABEL_PTR(trace_putself),
-    LABEL_PTR(trace_putobject),
-    LABEL_PTR(trace_putspecialobject),
-    LABEL_PTR(trace_putstring),
-    LABEL_PTR(trace_concatstrings),
-    LABEL_PTR(trace_anytostring),
-    LABEL_PTR(trace_toregexp),
-    LABEL_PTR(trace_intern),
-    LABEL_PTR(trace_newarray),
-    LABEL_PTR(trace_newarraykwsplat),
-    LABEL_PTR(trace_duparray),
-    LABEL_PTR(trace_duphash),
-    LABEL_PTR(trace_expandarray),
-    LABEL_PTR(trace_concatarray),
-    LABEL_PTR(trace_splatarray),
-    LABEL_PTR(trace_newhash),
-    LABEL_PTR(trace_newrange),
-    LABEL_PTR(trace_pop),
-    LABEL_PTR(trace_dup),
-    LABEL_PTR(trace_dupn),
-    LABEL_PTR(trace_swap),
-    LABEL_PTR(trace_topn),
-    LABEL_PTR(trace_setn),
-    LABEL_PTR(trace_adjuststack),
-    LABEL_PTR(trace_defined),
-    LABEL_PTR(trace_checkmatch),
-    LABEL_PTR(trace_checkkeyword),
-    LABEL_PTR(trace_checktype),
-    LABEL_PTR(trace_defineclass),
-    LABEL_PTR(trace_definemethod),
-    LABEL_PTR(trace_definesmethod),
-    LABEL_PTR(trace_send),
-    LABEL_PTR(trace_opt_send_without_block),
-    LABEL_PTR(trace_objtostring),
-    LABEL_PTR(trace_opt_str_freeze),
-    LABEL_PTR(trace_opt_nil_p),
-    LABEL_PTR(trace_opt_str_uminus),
-    LABEL_PTR(trace_opt_newarray_max),
-    LABEL_PTR(trace_opt_newarray_min),
-    LABEL_PTR(trace_invokesuper),
-    LABEL_PTR(trace_invokeblock),
-    LABEL_PTR(trace_leave),
-    LABEL_PTR(trace_throw),
-    LABEL_PTR(trace_jump),
-    LABEL_PTR(trace_branchif),
-    LABEL_PTR(trace_branchunless),
-    LABEL_PTR(trace_branchnil),
-    LABEL_PTR(trace_opt_getinlinecache),
-    LABEL_PTR(trace_opt_setinlinecache),
-    LABEL_PTR(trace_once),
-    LABEL_PTR(trace_opt_case_dispatch),
-    LABEL_PTR(trace_opt_plus),
-    LABEL_PTR(trace_opt_minus),
-    LABEL_PTR(trace_opt_mult),
-    LABEL_PTR(trace_opt_div),
-    LABEL_PTR(trace_opt_mod),
-    LABEL_PTR(trace_opt_eq),
-    LABEL_PTR(trace_opt_neq),
-    LABEL_PTR(trace_opt_lt),
-    LABEL_PTR(trace_opt_le),
-    LABEL_PTR(trace_opt_gt),
-    LABEL_PTR(trace_opt_ge),
-    LABEL_PTR(trace_opt_ltlt),
-    LABEL_PTR(trace_opt_and),
-    LABEL_PTR(trace_opt_or),
-    LABEL_PTR(trace_opt_aref),
-    LABEL_PTR(trace_opt_aset),
-    LABEL_PTR(trace_opt_aset_with),
-    LABEL_PTR(trace_opt_aref_with),
-    LABEL_PTR(trace_opt_length),
-    LABEL_PTR(trace_opt_size),
-    LABEL_PTR(trace_opt_empty_p),
-    LABEL_PTR(trace_opt_succ),
-    LABEL_PTR(trace_opt_not),
-    LABEL_PTR(trace_opt_regexpmatch2),
-    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),
-    LABEL_PTR(trace_setlocal_WC_1),
-    LABEL_PTR(trace_putobject_INT2FIX_0_),
-    LABEL_PTR(trace_putobject_INT2FIX_1_),
-};
-
-ASSERT_VM_INSTRUCTION_SIZE(insns_address_table);

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

@@ -1,73 +0,0 @@
-#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
-
-// We generate x86 assembly
-#if (defined(__x86_64__) && !defined(_WIN32)) || (defined(_WIN32) && defined(_M_AMD64)) // x64 platforms without mingw/msys
-# define YJIT_SUPPORTED_P 1
-#else
-# define YJIT_SUPPORTED_P 0
-#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;
-
-    // Disable the propagation of type information
-    bool no_type_prop;
-
-    // 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 *const iseq, IC ic);
-void rb_yjit_tracing_invalidate_all(void);
-
-#endif // #ifndef YJIT_H