debase-ruby_core_source 3.2.1 → 3.2.3

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_callinfo.h

@@ -43,6 +43,7 @@ enum vm_call_flag_bits {
 
 struct rb_callinfo_kwarg {
     int keyword_len;
+    int references;
     VALUE keywords[];
 };
 
@@ -65,8 +66,12 @@ struct rb_callinfo {
     VALUE argc;
 };
 
-#ifndef USE_EMBED_CI
+#if !defined(USE_EMBED_CI) || (USE_EMBED_CI+0)
+#undef USE_EMBED_CI
 #define USE_EMBED_CI 1
+#else
+#undef USE_EMBED_CI
+#define USE_EMBED_CI 0
 #endif
 
 #if SIZEOF_VALUE == 8
@@ -96,7 +101,9 @@ struct rb_callinfo {
 static inline bool
 vm_ci_packed_p(const struct rb_callinfo *ci)
 {
-#if USE_EMBED_CI
+    if (!USE_EMBED_CI) {
+        return 0;
+    }
     if (LIKELY(((VALUE)ci) & 0x01)) {
         return 1;
     }
@@ -104,9 +111,6 @@ vm_ci_packed_p(const struct rb_callinfo *ci)
         VM_ASSERT(IMEMO_TYPE_P(ci, imemo_callinfo));
         return 0;
     }
-#else
-    return 0;
-#endif
 }
 
 static inline bool
@@ -196,12 +200,13 @@ vm_ci_dump(const struct rb_callinfo *ci)
 static inline const struct rb_callinfo *
 vm_ci_new_(ID mid, unsigned int flag, unsigned int argc, const struct rb_callinfo_kwarg *kwarg, const char *file, int line)
 {
-#if USE_EMBED_CI
-    if (VM_CI_EMBEDDABLE_P(mid, flag, argc, kwarg)) {
+    if (kwarg) {
+        ((struct rb_callinfo_kwarg *)kwarg)->references++;
+    }
+    if (USE_EMBED_CI && VM_CI_EMBEDDABLE_P(mid, flag, argc, kwarg)) {
         RB_DEBUG_COUNTER_INC(ci_packed);
         return vm_ci_new_id(mid, flag, argc, kwarg);
     }
-#endif
 
     const bool debug = 0;
     if (debug) ruby_debug_printf("%s:%d ", file, line);
@@ -295,6 +300,17 @@ struct rb_callcache {
 #define VM_CALLCACHE_UNMARKABLE FL_FREEZE
 #define VM_CALLCACHE_ON_STACK   FL_EXIVAR
 
+#define VM_CALLCACHE_IVAR       IMEMO_FL_USER0
+#define VM_CALLCACHE_BF         IMEMO_FL_USER1
+#define VM_CALLCACHE_SUPER      IMEMO_FL_USER2
+#define VM_CALLCACHE_REFINEMENT IMEMO_FL_USER3
+
+enum vm_cc_type {
+    cc_type_normal, // chained from ccs
+    cc_type_super,
+    cc_type_refinement,
+};
+
 extern const struct rb_callcache *rb_vm_empty_cc(void);
 extern const struct rb_callcache *rb_vm_empty_cc_for_super(void);
 
@@ -311,14 +327,39 @@ vm_cc_attr_index_initialize(const struct rb_callcache *cc, shape_id_t shape_id)
 static inline const struct rb_callcache *
 vm_cc_new(VALUE klass,
           const struct rb_callable_method_entry_struct *cme,
-          vm_call_handler call)
+          vm_call_handler call,
+          enum vm_cc_type type)
 {
     const struct rb_callcache *cc = (const struct rb_callcache *)rb_imemo_new(imemo_callcache, (VALUE)cme, (VALUE)call, 0, klass);
+
+    switch (type) {
+      case cc_type_normal:
+        break;
+      case cc_type_super:
+        *(VALUE *)&cc->flags |= VM_CALLCACHE_SUPER;
+        break;
+      case cc_type_refinement:
+        *(VALUE *)&cc->flags |= VM_CALLCACHE_REFINEMENT;
+        break;
+    }
+
     vm_cc_attr_index_initialize(cc, INVALID_SHAPE_ID);
     RB_DEBUG_COUNTER_INC(cc_new);
     return cc;
 }
 
+static inline bool
+vm_cc_super_p(const struct rb_callcache *cc)
+{
+    return (cc->flags & VM_CALLCACHE_SUPER) != 0;
+}
+
+static inline bool
+vm_cc_refinement_p(const struct rb_callcache *cc)
+{
+    return (cc->flags & VM_CALLCACHE_REFINEMENT) != 0;
+}
+
 #define VM_CC_ON_STACK(clazz, call, aux, cme) \
     (struct rb_callcache) {                   \
         .flags = T_IMEMO |                    \
@@ -438,9 +479,6 @@ vm_cc_valid_p(const struct rb_callcache *cc, const rb_callable_method_entry_t *c
 
 /* callcache: mutate */
 
-#define VM_CALLCACH_IVAR IMEMO_FL_USER0
-#define VM_CALLCACH_BF IMEMO_FL_USER1
-
 static inline void
 vm_cc_call_set(const struct rb_callcache *cc, vm_call_handler call)
 {
@@ -460,13 +498,13 @@ vm_cc_attr_index_set(const struct rb_callcache *cc, attr_index_t index, shape_id
     VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
     VM_ASSERT(cc != vm_cc_empty());
     *attr_value = (attr_index_t)(index + 1) | ((uintptr_t)(dest_shape_id) << SHAPE_FLAG_SHIFT);
-    *(VALUE *)&cc->flags |= VM_CALLCACH_IVAR;
+    *(VALUE *)&cc->flags |= VM_CALLCACHE_IVAR;
 }
 
 static inline bool
 vm_cc_ivar_p(const struct rb_callcache *cc)
 {
-    return (cc->flags & VM_CALLCACH_IVAR) != 0;
+    return (cc->flags & VM_CALLCACHE_IVAR) != 0;
 }
 
 static inline void
@@ -495,13 +533,13 @@ vm_cc_bf_set(const struct rb_callcache *cc, const struct rb_builtin_function *bf
     VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
     VM_ASSERT(cc != vm_cc_empty());
     *(const struct rb_builtin_function **)&cc->aux_.bf = bf;
-    *(VALUE *)&cc->flags |= VM_CALLCACH_BF;
+    *(VALUE *)&cc->flags |= VM_CALLCACHE_BF;
 }
 
 static inline bool
 vm_cc_bf_p(const struct rb_callcache *cc)
 {
-    return (cc->flags & VM_CALLCACH_BF) != 0;
+    return (cc->flags & VM_CALLCACHE_BF) != 0;
 }
 
 static inline void

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_core.h

@@ -132,18 +132,9 @@ extern int ruby_assert_critical_section_entered;
 #define RUBY_NSIG NSIG
 
 #if defined(SIGCLD)
-#  define RUBY_SIGCHLD    (SIGCLD)
+#  define RUBY_SIGCHLD (SIGCLD)
 #elif defined(SIGCHLD)
-#  define RUBY_SIGCHLD    (SIGCHLD)
-#else
-#  define RUBY_SIGCHLD    (0)
-#endif
-
-/* platforms with broken or non-existent SIGCHLD work by polling */
-#if defined(__APPLE__)
-#  define SIGCHLD_LOSSY (1)
-#else
-#  define SIGCHLD_LOSSY (0)
+#  define RUBY_SIGCHLD (SIGCHLD)
 #endif
 
 #if defined(SIGSEGV) && defined(HAVE_SIGALTSTACK) && defined(SA_SIGINFO) && !defined(__NetBSD__)
@@ -191,9 +182,6 @@ void *rb_register_sigaltstack(void *);
 #if    OPT_DIRECT_THREADED_CODE
 #undef OPT_DIRECT_THREADED_CODE
 #endif /* OPT_DIRECT_THREADED_CODE */
-#if    OPT_STACK_CACHING
-#undef OPT_STACK_CACHING
-#endif /* OPT_STACK_CACHING */
 #endif /* OPT_CALL_THREADED_CODE */
 
 void rb_vm_encoded_insn_data_table_init(void);
@@ -290,7 +278,7 @@ union iseq_inline_storage_entry {
 };
 
 struct rb_calling_info {
-    const struct rb_callinfo *ci;
+    const struct rb_call_data *cd;
     const struct rb_callcache *cc;
     VALUE block_handler;
     VALUE recv;
@@ -515,10 +503,17 @@ struct rb_iseq_constant_body {
     const rb_iseq_t *mandatory_only_iseq;
 
 #if USE_RJIT || USE_YJIT
-    // Function pointer for JIT code
-    rb_jit_func_t jit_func;
-    // Number of total calls with jit_exec()
-    long unsigned total_calls;
+    // Function pointer for JIT code on jit_exec()
+    rb_jit_func_t jit_entry;
+    // Number of calls on jit_exec()
+    long unsigned jit_entry_calls;
+#endif
+
+#if USE_YJIT
+    // Function pointer for JIT code on jit_exec_exception()
+    rb_jit_func_t jit_exception;
+    // Number of calls on jit_exec_exception()
+    long unsigned jit_exception_calls;
 #endif
 
 #if USE_RJIT
@@ -529,6 +524,8 @@ struct rb_iseq_constant_body {
 #if USE_YJIT
     // YJIT stores some data on each iseq.
     void *yjit_payload;
+    // Used to estimate how frequently this ISEQ gets called
+    uint64_t yjit_calls_at_interv;
 #endif
 };
 
@@ -557,22 +554,21 @@ struct rb_iseq_struct {
 
 #define ISEQ_BODY(iseq) ((iseq)->body)
 
-#ifndef USE_LAZY_LOAD
+#if !defined(USE_LAZY_LOAD) || !(USE_LAZY_LOAD+0)
 #define USE_LAZY_LOAD 0
 #endif
 
-#if USE_LAZY_LOAD
-const rb_iseq_t *rb_iseq_complete(const rb_iseq_t *iseq);
+#if !USE_LAZY_LOAD
+static inline const rb_iseq_t *rb_iseq_complete(const rb_iseq_t *iseq) {return 0;}
 #endif
+const rb_iseq_t *rb_iseq_complete(const rb_iseq_t *iseq);
 
 static inline const rb_iseq_t *
 rb_iseq_check(const rb_iseq_t *iseq)
 {
-#if USE_LAZY_LOAD
-    if (ISEQ_BODY(iseq) == NULL) {
+    if (USE_LAZY_LOAD && ISEQ_BODY(iseq) == NULL) {
         rb_iseq_complete((rb_iseq_t *)iseq);
     }
-#endif
     return iseq;
 }
 
@@ -640,15 +636,51 @@ typedef struct rb_vm_struct {
             struct rb_ractor_struct *lock_owner;
             unsigned int lock_rec;
 
-            // barrier
-            bool barrier_waiting;
-            unsigned int barrier_cnt;
-            rb_nativethread_cond_t barrier_cond;
-
             // join at exit
             rb_nativethread_cond_t terminate_cond;
             bool terminate_waiting;
+
+#ifndef RUBY_THREAD_PTHREAD_H
+            bool barrier_waiting;
+            unsigned int barrier_cnt;
+            rb_nativethread_cond_t barrier_cond;
+#endif
         } sync;
+
+        // ractor scheduling
+        struct {
+            rb_nativethread_lock_t lock;
+            struct rb_ractor_struct *lock_owner;
+            bool locked;
+
+            rb_nativethread_cond_t cond; // GRQ
+            unsigned int snt_cnt; // count of shared NTs
+            unsigned int dnt_cnt; // count of dedicated NTs
+
+            unsigned int running_cnt;
+
+            unsigned int max_cpu;
+            struct ccan_list_head grq; // // Global Ready Queue
+            unsigned int grq_cnt;
+
+            // running threads
+            struct ccan_list_head running_threads;
+
+            // threads which switch context by timeslice
+            struct ccan_list_head timeslice_threads;
+
+            struct ccan_list_head zombie_threads;
+
+            // true if timeslice timer is not enable
+            bool timeslice_wait_inf;
+
+            // barrier
+            rb_nativethread_cond_t barrier_complete_cond;
+            rb_nativethread_cond_t barrier_release_cond;
+            bool barrier_waiting;
+            unsigned int barrier_waiting_cnt;
+            unsigned int barrier_serial;
+        } sched;
     } ractor;
 
 #ifdef USE_SIGALTSTACK
@@ -819,19 +851,16 @@ struct rb_block {
 };
 
 typedef struct rb_control_frame_struct {
-    const VALUE *pc;		/* cfp[0] */
-    VALUE *sp;			/* cfp[1] */
-    const rb_iseq_t *iseq;	/* cfp[2] */
-    VALUE self;			/* cfp[3] / block[0] */
-    const VALUE *ep;		/* cfp[4] / block[1] */
-    const void *block_code;     /* cfp[5] / block[2] */ /* iseq or ifunc or forwarded block handler */
-    VALUE *__bp__;              /* cfp[6] */ /* outside vm_push_frame, use vm_base_ptr instead. */
-
+    const VALUE *pc;        // cfp[0]
+    VALUE *sp;              // cfp[1]
+    const rb_iseq_t *iseq;  // cfp[2]
+    VALUE self;             // cfp[3] / block[0]
+    const VALUE *ep;        // cfp[4] / block[1]
+    const void *block_code; // cfp[5] / block[2] -- iseq, ifunc, or forwarded block handler
+    void *jit_return;       // cfp[6] -- return address for JIT code
 #if VM_DEBUG_BP_CHECK
-    VALUE *bp_check;		/* cfp[7] */
+    VALUE *bp_check;        // cfp[7]
 #endif
-    // Return address for YJIT code
-    void *jit_return;
 } rb_control_frame_t;
 
 extern const rb_data_type_t ruby_threadptr_data_type;
@@ -1559,12 +1588,6 @@ vm_block_handler_verify(MAYBE_UNUSED(VALUE block_handler))
               (vm_block_handler_type(block_handler), 1));
 }
 
-static inline int
-vm_cfp_forwarded_bh_p(const rb_control_frame_t *cfp, VALUE block_handler)
-{
-    return ((VALUE) cfp->block_code) == block_handler;
-}
-
 static inline enum rb_block_type
 vm_block_type(const struct rb_block *block)
 {
@@ -1693,17 +1716,13 @@ VALUE rb_proc_alloc(VALUE klass);
 VALUE rb_proc_dup(VALUE self);
 
 /* for debug */
-extern void rb_vmdebug_stack_dump_raw(const rb_execution_context_t *ec, const rb_control_frame_t *cfp);
-extern void rb_vmdebug_debug_print_pre(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, const VALUE *_pc);
-extern void rb_vmdebug_debug_print_post(const rb_execution_context_t *ec, const rb_control_frame_t *cfp
-#if OPT_STACK_CACHING
-    , VALUE reg_a, VALUE reg_b
-#endif
-);
+extern bool rb_vmdebug_stack_dump_raw(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, FILE *);
+extern bool rb_vmdebug_debug_print_pre(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, const VALUE *_pc, FILE *);
+extern bool rb_vmdebug_debug_print_post(const rb_execution_context_t *ec, const rb_control_frame_t *cfp, FILE *);
 
-#define SDR() rb_vmdebug_stack_dump_raw(GET_EC(), GET_EC()->cfp)
-#define SDR2(cfp) rb_vmdebug_stack_dump_raw(GET_EC(), (cfp))
-void rb_vm_bugreport(const void *);
+#define SDR() rb_vmdebug_stack_dump_raw(GET_EC(), GET_EC()->cfp, stderr)
+#define SDR2(cfp) rb_vmdebug_stack_dump_raw(GET_EC(), (cfp), stderr)
+bool rb_vm_bugreport(const void *, FILE *);
 typedef void (*ruby_sighandler_t)(int);
 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 4, 5)
 NORETURN(void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *, const char *fmt, ...));
@@ -1758,6 +1777,7 @@ rb_vm_living_threads_init(rb_vm_t *vm)
     ccan_list_head_init(&vm->waiting_fds);
     ccan_list_head_init(&vm->workqueue);
     ccan_list_head_init(&vm->ractor.set);
+    ccan_list_head_init(&vm->ractor.sched.zombie_threads);
 }
 
 typedef int rb_backtrace_iter_func(void *, VALUE, int, VALUE);
@@ -1771,6 +1791,7 @@ rb_thread_t * ruby_thread_from_native(void);
 int ruby_thread_set_native(rb_thread_t *th);
 int rb_vm_control_frame_id_and_class(const rb_control_frame_t *cfp, ID *idp, ID *called_idp, VALUE *klassp);
 void rb_vm_rewind_cfp(rb_execution_context_t *ec, rb_control_frame_t *cfp);
+void rb_vm_env_write(const VALUE *ep, int index, VALUE v);
 VALUE rb_vm_bh_to_procval(const rb_execution_context_t *ec, VALUE block_handler);
 
 void rb_vm_register_special_exception_str(enum ruby_special_exceptions sp, VALUE exception_class, VALUE mesg);
@@ -1857,6 +1878,20 @@ rb_current_execution_context(bool expect_ec)
   #else
     rb_execution_context_t *ec = ruby_current_ec;
   #endif
+
+    /* On the shared objects, `__tls_get_addr()` is used to access the TLS
+     * and the address of the `ruby_current_ec` can be stored on a function
+     * frame. However, this address can be mis-used after native thread
+     * migration of a coroutine.
+     *   1) Get `ptr =&ruby_current_ec` op NT1 and store it on the frame.
+     *   2) Context switch and resume it on the NT2.
+     *   3) `ptr` is used on NT2 but it accesses to the TLS on NT1.
+     * This assertion checks such misusage.
+     *
+     * To avoid accidents, `GET_EC()` should be called once on the frame.
+     * Note that inlining can produce the problem.
+     */
+    VM_ASSERT(ec == rb_current_ec_noinline());
 #else
     rb_execution_context_t *ec = native_tls_get(ruby_current_ec_key);
 #endif

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

@@ -21,11 +21,7 @@ typedef rb_iseq_t *ISEQ;
 #define DEBUG_ENTER_INSN(insn) \
     rb_vmdebug_debug_print_pre(ec, GET_CFP(), GET_PC());
 
-#if OPT_STACK_CACHING
-#define SC_REGS() , reg_a, reg_b
-#else
 #define SC_REGS()
-#endif
 
 #define DEBUG_END_INSN() \
   rb_vmdebug_debug_print_post(ec, GET_CFP() SC_REGS());
@@ -40,10 +36,6 @@ typedef rb_iseq_t *ISEQ;
 #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)
 error !
@@ -80,8 +72,7 @@ error !
                         (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)); \
-  } \
-  if (USE_INSNS_COUNTER) vm_insns_counter_count_insn(BIN(insn));
+  }
 
 #define INSN_DISPATCH_SIG(insn)
 
@@ -174,10 +165,20 @@ default:                        \
 #define THROW_EXCEPTION(exc) return (VALUE)(exc)
 #endif
 
+// Run the interpreter from the JIT
+#define VM_EXEC(ec, val) do { \
+    if (val == Qundef) { \
+        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; \
     if (val == Qundef && (func = jit_compile(ec))) { \
         val = func(ec, ec->cfp); \
+        RESTORE_REGS(); /* fix cfp for tailcall */ \
         if (ec->tag->state) THROW_EXCEPTION(val); \
     } \
 } while (0)

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

@@ -20,30 +20,29 @@ RUBY_EXTERN rb_serial_t ruby_vm_global_cvar_state;
 # define RJIT_STATS RUBY_DEBUG
 #endif
 
+#if USE_YJIT // We want vm_insns_count on any YJIT-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 YJIT_COLLECT_USAGE_INSN(insn) rb_vm_insns_count++
+#else
+#define YJIT_COLLECT_USAGE_INSN(insn) // none
+#endif
+
+#if RJIT_STATS
+#define RJIT_COLLECT_USAGE_INSN(insn) rb_rjit_collect_vm_usage_insn(insn)
+#else
+#define RJIT_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))
-#elif RJIT_STATS && YJIT_STATS
-// Both flags could be enabled at the same time. You need to call both in that case.
-#define COLLECT_USAGE_INSN(insn)           rb_rjit_collect_vm_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 */
-#elif RJIT_STATS
-// for --rjit-stats
-#define COLLECT_USAGE_INSN(insn)           rb_rjit_collect_vm_usage_insn(insn)
-#define COLLECT_USAGE_OPERAND(insn, n, op)	/* none */
-#define COLLECT_USAGE_REGISTER(reg, s)		/* none */
-#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)           YJIT_COLLECT_USAGE_INSN(insn); RJIT_COLLECT_USAGE_INSN(insn)
+#define COLLECT_USAGE_OPERAND(insn, n, op) // none
+#define COLLECT_USAGE_REGISTER(reg, s)     // none
 #endif
 
 /**********************************************************/
@@ -182,10 +181,8 @@ CC_SET_FASTPATH(const struct rb_callcache *cc, vm_call_handler func, bool enable
 /**********************************************************/
 
 #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); \
+    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)
 

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/vm_opts.h

@@ -54,17 +54,12 @@
 #define OPT_OPERANDS_UNIFICATION     1
 #define OPT_INSTRUCTIONS_UNIFICATION 0
 #define OPT_UNIFY_ALL_COMBINATION    0
-#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
 #endif

data/lib/debase/ruby_core_source/{ruby-3.3.0-preview1 → ruby-3.3.0-preview3}/yjit.h

@@ -25,16 +25,17 @@
 #endif
 
 // Expose these as declarations since we are building YJIT.
-bool rb_yjit_enabled_p(void);
-bool rb_yjit_compile_new_iseqs(void);
-unsigned rb_yjit_call_threshold(void);
+extern uint64_t rb_yjit_call_threshold;
+extern uint64_t rb_yjit_cold_threshold;
+extern uint64_t rb_yjit_live_iseq_count;
+extern bool rb_yjit_enabled_p;
+void rb_yjit_incr_counter(const char *counter_name);
 void rb_yjit_invalidate_all_method_lookup_assumptions(void);
 void rb_yjit_cme_invalidate(rb_callable_method_entry_t *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(void);
+void rb_yjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec, bool jit_exception);
+void rb_yjit_init(bool yjit_enabled);
 void rb_yjit_bop_redefined(int redefined_flag, enum ruby_basic_operators bop);
 void rb_yjit_constant_state_changed(ID id);
 void rb_yjit_iseq_mark(void *payload);
@@ -43,21 +44,20 @@ void rb_yjit_iseq_free(void *payload);
 void rb_yjit_before_ractor_spawn(void);
 void rb_yjit_constant_ic_update(const rb_iseq_t *const iseq, IC ic, unsigned insn_idx);
 void rb_yjit_tracing_invalidate_all(void);
+void rb_yjit_show_usage(int help, int highlight, unsigned int width, int columns);
 
 #else
 // !USE_YJIT
 // In these builds, YJIT could never be turned on. Provide dummy implementations.
 
-static inline bool rb_yjit_enabled_p(void) { return false; }
-static inline bool rb_yjit_compile_new_iseqs(void) { return false; }
-static inline unsigned rb_yjit_call_threshold(void) { return UINT_MAX; }
+#define rb_yjit_enabled_p false
+static inline void rb_yjit_incr_counter(const char *counter_name) {}
 static inline void rb_yjit_invalidate_all_method_lookup_assumptions(void) {}
 static inline void rb_yjit_cme_invalidate(rb_callable_method_entry_t *cme) {}
-static inline void rb_yjit_collect_vm_usage_insn(int insn) {}
 static inline void rb_yjit_collect_binding_alloc(void) {}
 static inline void rb_yjit_collect_binding_set(void) {}
-static inline bool rb_yjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec) { return false; }
-static inline void rb_yjit_init(void) {}
+static inline void rb_yjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec, bool jit_exception) {}
+static inline void rb_yjit_init(bool yjit_enabled) {}
 static inline void rb_yjit_bop_redefined(int redefined_flag, enum ruby_basic_operators bop) {}
 static inline void rb_yjit_constant_state_changed(ID id) {}
 static inline void rb_yjit_iseq_mark(void *payload) {}

data/lib/debase/ruby_core_source/version.rb

@@ -1,5 +1,5 @@
 module Debase
   module RubyCoreSource
-   VERSION = '3.2.1'
+    VERSION = '3.2.3'
   end
 end