debase-ruby_core_source 0.10.13 → 0.10.16

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/vm_callinfo.h

@@ -290,6 +290,7 @@ struct rb_callcache {
 };
 
 #define VM_CALLCACHE_UNMARKABLE IMEMO_FL_USER0
+#define VM_CALLCACHE_ON_STACK   IMEMO_FL_USER1
 
 static inline const struct rb_callcache *
 vm_cc_new(VALUE klass,
@@ -305,7 +306,8 @@ vm_cc_new(VALUE klass,
     (struct rb_callcache) {                   \
         .flags = T_IMEMO |                    \
             (imemo_callcache << FL_USHIFT) |  \
-            VM_CALLCACHE_UNMARKABLE,          \
+            VM_CALLCACHE_UNMARKABLE |         \
+            VM_CALLCACHE_ON_STACK,            \
         .klass = clazz,                       \
         .cme_  = cme,                         \
         .call_ = call,                        \
@@ -321,10 +323,21 @@ vm_cc_class_check(const struct rb_callcache *cc, VALUE klass)
     return cc->klass == klass;
 }
 
+static inline int
+vm_cc_markable(const struct rb_callcache *cc)
+{
+    VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
+    return FL_TEST_RAW((VALUE)cc, VM_CALLCACHE_UNMARKABLE) == 0;
+}
+
 static inline const struct rb_callable_method_entry_struct *
 vm_cc_cme(const struct rb_callcache *cc)
 {
     VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
+    VM_ASSERT(cc->call_ == NULL   || // not initialized yet
+              !vm_cc_markable(cc) ||
+              cc->cme_ != NULL);
+
     return cc->cme_;
 }
 
@@ -332,6 +345,7 @@ static inline vm_call_handler
 vm_cc_call(const struct rb_callcache *cc)
 {
     VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
+    VM_ASSERT(cc->call_ != NULL);
     return cc->call_;
 }
 
@@ -349,13 +363,6 @@ vm_cc_cmethod_missing_reason(const struct rb_callcache *cc)
     return cc->aux_.method_missing_reason;
 }
 
-static inline int
-vm_cc_markable(const struct rb_callcache *cc)
-{
-    VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
-    return FL_TEST_RAW((VALUE)cc, VM_CALLCACHE_UNMARKABLE) == 0;
-}
-
 static inline bool
 vm_cc_invalidated_p(const struct rb_callcache *cc)
 {
@@ -381,6 +388,7 @@ vm_cc_valid_p(const struct rb_callcache *cc, const rb_callable_method_entry_t *c
 }
 
 extern const struct rb_callcache *rb_vm_empty_cc(void);
+extern const struct rb_callcache *rb_vm_empty_cc_for_super(void);
 #define vm_cc_empty() rb_vm_empty_cc()
 
 /* callcache: mutate */
@@ -441,11 +449,36 @@ struct rb_class_cc_entries {
 };
 
 #if VM_CHECK_MODE > 0
+
+const rb_callable_method_entry_t *rb_vm_lookup_overloaded_cme(const rb_callable_method_entry_t *cme);
+void rb_vm_dump_overloaded_cme_table(void);
+
 static inline bool
 vm_ccs_p(const struct rb_class_cc_entries *ccs)
 {
     return ccs->debug_sig == ~(VALUE)ccs;
 }
+
+static inline bool
+vm_cc_check_cme(const struct rb_callcache *cc, const rb_callable_method_entry_t *cme)
+{
+    if (vm_cc_cme(cc) == cme ||
+        (cme->def->iseq_overload && vm_cc_cme(cc) == rb_vm_lookup_overloaded_cme(cme))) {
+        return true;
+    }
+    else {
+#if 1
+        // debug print
+
+        fprintf(stderr, "iseq_overload:%d\n", (int)cme->def->iseq_overload);
+        rp(cme);
+        rp(vm_cc_cme(cc));
+        rb_vm_lookup_overloaded_cme(cme);
+#endif
+        return false;
+    }
+}
+
 #endif
 
 // gc.c

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/vm_core.h

@@ -482,6 +482,8 @@ struct rb_iseq_constant_body {
     bool builtin_inline_p;
     struct rb_id_table *outer_variables;
 
+    const rb_iseq_t *mandatory_only_iseq;
+
 #if USE_MJIT
     /* The following fields are MJIT related info.  */
     VALUE (*jit_func)(struct rb_execution_context_struct *,
@@ -607,8 +609,9 @@ void rb_objspace_call_finalizer(struct rb_objspace *);
 typedef struct rb_hook_list_struct {
     struct rb_event_hook_struct *hooks;
     rb_event_flag_t events;
-    unsigned int need_clean;
     unsigned int running;
+    bool need_clean;
+    bool is_local;
 } rb_hook_list_t;
 
 
@@ -711,6 +714,7 @@ typedef struct rb_vm_struct {
     int builtin_inline_index;
 
     struct rb_id_table *negative_cme_table;
+    st_table *overloaded_cme_table; // cme -> overloaded_cme
 
 #ifndef VM_GLOBAL_CC_CACHE_TABLE_SIZE
 #define VM_GLOBAL_CC_CACHE_TABLE_SIZE 1023
@@ -1103,7 +1107,7 @@ RUBY_SYMBOL_EXPORT_BEGIN
 /* node -> iseq */
 rb_iseq_t *rb_iseq_new         (const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath,                     const rb_iseq_t *parent, enum iseq_type);
 rb_iseq_t *rb_iseq_new_top     (const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath,                     const rb_iseq_t *parent);
-rb_iseq_t *rb_iseq_new_main    (const rb_ast_body_t *ast,             VALUE path, VALUE realpath,                     const rb_iseq_t *parent);
+rb_iseq_t *rb_iseq_new_main    (const rb_ast_body_t *ast,             VALUE path, VALUE realpath,                     const rb_iseq_t *parent, int opt);
 rb_iseq_t *rb_iseq_new_eval    (const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno, const rb_iseq_t *parent, int isolated_depth);
 rb_iseq_t *rb_iseq_new_with_opt(const rb_ast_body_t *ast, VALUE name, VALUE path, VALUE realpath, VALUE first_lineno, const rb_iseq_t *parent, int isolated_depth,
                                 enum iseq_type, const rb_compile_option_t*);

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/vm_debug.h

@@ -12,7 +12,6 @@
 **********************************************************************/
 
 #include "ruby/ruby.h"
-#include "node.h"
 
 RUBY_SYMBOL_EXPORT_BEGIN
 
@@ -21,15 +20,21 @@ RUBY_SYMBOL_EXPORT_BEGIN
 #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);
-NODE *ruby_debug_print_node(int level, int debug_level, const char *header, const NODE *node);
+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 RUBY_DEVEL
+# define RUBY_DEVEL 0
+#endif
+
 #if RUBY_DEVEL
 #ifndef USE_RUBY_DEBUG_LOG
 #define USE_RUBY_DEBUG_LOG 0
@@ -96,7 +101,7 @@ bool ruby_debug_log_filter(const char *func_name);
 // 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
+#if defined(USE_RUBY_DEBUG_LOG) && USE_RUBY_DEBUG_LOG
 # define RUBY_DEBUG_LOG_ENABLED(func_name) \
     (ruby_debug_log_mode && ruby_debug_log_filter(func_name))
 

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

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

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

@@ -58,7 +58,7 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(putspecialobject),
     LABEL_PTR(putstring),
     LABEL_PTR(concatstrings),
-    LABEL_PTR(tostring),
+    LABEL_PTR(anytostring),
     LABEL_PTR(toregexp),
     LABEL_PTR(intern),
     LABEL_PTR(newarray),
@@ -86,6 +86,7 @@ static const void *const insns_address_table[] = {
     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),
@@ -158,7 +159,7 @@ static const void *const insns_address_table[] = {
     LABEL_PTR(trace_putspecialobject),
     LABEL_PTR(trace_putstring),
     LABEL_PTR(trace_concatstrings),
-    LABEL_PTR(trace_tostring),
+    LABEL_PTR(trace_anytostring),
     LABEL_PTR(trace_toregexp),
     LABEL_PTR(trace_intern),
     LABEL_PTR(trace_newarray),
@@ -186,6 +187,7 @@ static const void *const insns_address_table[] = {
     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),

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/yjit.h

@@ -15,6 +15,13 @@
 # define YJIT_STATS RUBY_DEBUG
 #endif
 
+// We generate x86 assembly and rely on mmap(2).
+#if defined(__x86_64__) && !defined(_WIN32)
+# define YJIT_SUPPORTED_P 1
+#else
+# define YJIT_SUPPORTED_P 0
+#endif
+
 struct rb_yjit_options {
     // Enable compilation with YJIT
     bool yjit_enabled;
@@ -29,6 +36,9 @@ struct rb_yjit_options {
     // 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;
@@ -57,7 +67,7 @@ void rb_yjit_iseq_mark(const struct rb_iseq_constant_body *body);
 void rb_yjit_iseq_update_references(const struct rb_iseq_constant_body *body);
 void rb_yjit_iseq_free(const struct rb_iseq_constant_body *body);
 void rb_yjit_before_ractor_spawn(void);
-void rb_yjit_constant_ic_update(const rb_iseq_t *iseq, IC ic);
+void rb_yjit_constant_ic_update(const rb_iseq_t *const iseq, IC ic);
 void rb_yjit_tracing_invalidate_all(void);
 
 #endif // #ifndef YJIT_H

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/yjit_asm.h

@@ -26,12 +26,13 @@ typedef struct LabelRef
 typedef struct CodeBlock
 {
     // Memory block
-    uint8_t *mem_block;
+    // Users are advised to not use this directly.
+    uint8_t *mem_block_;
 
     // Memory block size
     uint32_t mem_size;
 
-    /// Current writing position
+    // Current writing position
     uint32_t write_pos;
 
     // Table of registered label addresses
@@ -50,13 +51,25 @@ typedef struct CodeBlock
     // Number of references to labels
     uint32_t num_refs;
 
-    // TODO: system for disassembly/comment strings, indexed by position
+
+    // Keep track of the current aligned write position.
+    // Used for changing protection when writing to the JIT buffer
+    uint32_t current_aligned_write_pos;
+
+    // Set if the assembler is unable to output some instructions,
+    // for example, when there is not enough space or when a jump
+    // target is too far away.
+    bool dropped_bytes;
 
     // Flag to enable or disable comments
     bool has_asm;
 
+
 } codeblock_t;
 
+// 1 is not aligned so this won't match any pages
+#define ALIGNED_WRITE_POSITION_NONE 1
+
 enum OpndType
 {
     OPND_NONE,
@@ -252,8 +265,8 @@ static inline void cb_init(codeblock_t *cb, uint8_t *mem_block, uint32_t mem_siz
 static inline void cb_align_pos(codeblock_t *cb, uint32_t multiple);
 static inline void cb_set_pos(codeblock_t *cb, uint32_t pos);
 static inline void cb_set_write_ptr(codeblock_t *cb, uint8_t *code_ptr);
-static inline uint8_t *cb_get_ptr(codeblock_t *cb, uint32_t index);
-static inline uint8_t *cb_get_write_ptr(codeblock_t *cb);
+static inline uint8_t *cb_get_ptr(const codeblock_t *cb, uint32_t index);
+static inline uint8_t *cb_get_write_ptr(const codeblock_t *cb);
 static inline void cb_write_byte(codeblock_t *cb, uint8_t byte);
 static inline void cb_write_bytes(codeblock_t *cb, uint32_t num_bytes, ...);
 static inline void cb_write_int(codeblock_t *cb, uint64_t val, uint32_t num_bits);
@@ -261,6 +274,9 @@ static inline uint32_t cb_new_label(codeblock_t *cb, const char *name);
 static inline void cb_write_label(codeblock_t *cb, uint32_t label_idx);
 static inline void cb_label_ref(codeblock_t *cb, uint32_t label_idx);
 static inline void cb_link_labels(codeblock_t *cb);
+static inline void cb_mark_all_writeable(codeblock_t *cb);
+static inline void cb_mark_position_writeable(codeblock_t *cb, uint32_t write_pos);
+static inline void cb_mark_all_executable(codeblock_t *cb);
 
 // Encode individual instructions into a code block
 static inline void add(codeblock_t *cb, x86opnd_t opnd0, x86opnd_t opnd1);

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/yjit_codegen.h

@@ -10,9 +10,13 @@ typedef enum codegen_status {
 // Code generation function signature
 typedef codegen_status_t (*codegen_fn)(jitstate_t *jit, ctx_t *ctx, codeblock_t *cb);
 
+static void jit_ensure_block_entry_exit(jitstate_t *jit);
+
 static uint8_t *yjit_entry_prologue(codeblock_t *cb, const rb_iseq_t *iseq);
 
-static void yjit_gen_block(block_t *block, rb_execution_context_t *ec);
+static block_t *gen_single_block(blockid_t blockid, const ctx_t *start_ctx, rb_execution_context_t *ec);
+
+static void gen_code_for_exit_from_stub(void);
 
 static void yjit_init_codegen(void);
 

data/lib/debase/ruby_core_source/{ruby-3.1.0-preview1 → ruby-3.1.0-p0}/yjit_core.h

@@ -192,11 +192,12 @@ typedef struct yjit_branch_entry
     struct yjit_block_version *block;
 
     // Positions where the generated code starts and ends
-    uint8_t* start_addr;
-    uint8_t* end_addr;
+    uint8_t *start_addr;
+    uint8_t *end_addr;
 
     // Context right after the branch instruction
-    ctx_t src_ctx;
+    // Unused for now.
+    // ctx_t src_ctx;
 
     // Branch target blocks and their contexts
     blockid_t targets[2];
@@ -204,7 +205,7 @@ typedef struct yjit_branch_entry
     struct yjit_block_version *blocks[2];
 
     // Jump target addresses
-    uint8_t* dst_addrs[2];
+    uint8_t *dst_addrs[2];
 
     // Branch code generation function
     branchgen_fn gen_fn;
@@ -241,8 +242,8 @@ typedef struct yjit_block_version
     ctx_t ctx;
 
     // Positions where the generated code starts and ends
-    uint8_t* start_addr;
-    uint8_t* end_addr;
+    uint8_t *start_addr;
+    uint8_t *end_addr;
 
     // List of incoming branches (from predecessors)
     branch_array_t incoming;
@@ -258,6 +259,10 @@ typedef struct yjit_block_version
     // block in the system.
     cme_dependency_array_t cme_dependencies;
 
+    // Code address of an exit for `ctx` and `blockid`. Used for block
+    // invalidation.
+    uint8_t *entry_exit;
+
     // Index one past the last instruction in the iseq
     uint32_t end_idx;
 

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

@@ -0,0 +1,20 @@
+#ifndef RUBY_ADDR2LINE_H
+#define RUBY_ADDR2LINE_H
+/**********************************************************************
+
+  addr2line.h -
+
+  $Author$
+
+  Copyright (C) 2010 Shinichiro Hamaji
+
+**********************************************************************/
+
+#if (defined(USE_ELF) || defined(HAVE_MACH_O_LOADER_H))
+
+void
+rb_dump_backtrace_with_lines(int num_traces, void **traces);
+
+#endif /* USE_ELF */
+
+#endif /* RUBY_ADDR2LINE_H */

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

@@ -0,0 +1,84 @@
+#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)){}
+
+PUREFUNC(VALUE rb_vm_lvar_exposed(rb_execution_context_t *ec, int index));
+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-3.2.0-preview1/ccan/build_assert/build_assert.h

@@ -0,0 +1,40 @@
+/* CC0 (Public domain) - see ccan/licenses/CC0 file for details */
+#ifndef CCAN_BUILD_ASSERT_H
+#define CCAN_BUILD_ASSERT_H
+
+/**
+ * CCAN_BUILD_ASSERT - assert a build-time dependency.
+ * @cond: the compile-time condition which must be true.
+ *
+ * Your compile will fail if the condition isn't true, or can't be evaluated
+ * 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.
+ *		CCAN_BUILD_ASSERT(offsetof(struct foo, string) == 0);
+ *		return (char *)foo;
+ *	}
+ */
+#define CCAN_BUILD_ASSERT(cond) \
+	do { (void) sizeof(char [1 - 2*!(cond)]); } while(0)
+
+/**
+ * CCAN_BUILD_ASSERT_OR_ZERO - assert a build-time dependency, as an expression.
+ * @cond: the compile-time condition which must be true.
+ *
+ * Your compile will fail if the condition isn't true, or can't be evaluated
+ * by the compiler.  This can be used in an expression: its value is "0".
+ *
+ * Example:
+ *	#define foo_to_char(foo)					\
+ *		 ((char *)(foo)						\
+ *		  + CCAN_BUILD_ASSERT_OR_ZERO(offsetof(struct foo, string) == 0))
+ */
+#define CCAN_BUILD_ASSERT_OR_ZERO(cond) \
+	(sizeof(char [1 - 2*!(cond)]) - 1)
+
+#endif /* CCAN_BUILD_ASSERT_H */