debase-ruby_core_source 0.10.13 → 0.10.14

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-preview1 → ruby-3.1.0-p0}/vm_sync.h

@@ -4,7 +4,7 @@
 #include "vm_debug.h"
 #include "debug_counter.h"
 
-#if USE_RUBY_DEBUG_LOG
+#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

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/version.rb

@@ -1,5 +1,5 @@
 module Debase
   module RubyCoreSource
-   VERSION = '0.10.13'
+   VERSION = '0.10.14'
   end
 end