1 files changed, 296 insertions, 105 deletions

diff --git a/vm_method.c b/vm_method.c
index fb217ef43d..59906f9b16 100644
--- a/vm_method.c
+++ b/vm_method.c
@@ -40,7 +40,7 @@ mark_cc_entry_i(VALUE ccs_ptr, void *data)
             VM_ASSERT(!vm_cc_super_p(cc) && !vm_cc_refinement_p(cc));
             vm_cc_invalidate(cc);
         }
-        ruby_xfree(ccs);
+        ruby_xfree_sized(ccs, vm_ccs_alloc_size(ccs->capa));
         return ID_TABLE_DELETE;
     }
     else {
@@ -71,7 +71,7 @@ cc_table_free_i(VALUE ccs_ptr, void *data)
     struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_ptr;
     VM_ASSERT(vm_ccs_p(ccs));
 
-    ruby_xfree(ccs);
+    ruby_xfree_sized(ccs, vm_ccs_alloc_size(ccs->capa));
 
     return ID_TABLE_CONTINUE;
 }
@@ -149,10 +149,21 @@ vm_cc_table_dup_i(ID key, VALUE old_ccs_ptr, void *data)
 {
     VALUE new_table = (VALUE)data;
     struct rb_class_cc_entries *old_ccs = (struct rb_class_cc_entries *)old_ccs_ptr;
+
+    if (METHOD_ENTRY_INVALIDATED(old_ccs->cme)) {
+        // Invalidated CME. This entry will be removed from the old table on
+        // the next GC mark, so it's unsafe (and undesirable) to copy
+        return ID_TABLE_CONTINUE;
+    }
+
     size_t memsize = vm_ccs_alloc_size(old_ccs->capa);
     struct rb_class_cc_entries *new_ccs = ruby_xcalloc(1, memsize);
     rb_managed_id_table_insert(new_table, key, (VALUE)new_ccs);
 
+    // We hold the VM lock, so invalidation should not have happened between
+    // our earlier invalidation check and now.
+    VM_ASSERT(!METHOD_ENTRY_INVALIDATED(old_ccs->cme));
+
     memcpy(new_ccs, old_ccs, memsize);
 
 #if VM_CHECK_MODE > 0
@@ -169,6 +180,7 @@ vm_cc_table_dup_i(ID key, VALUE old_ccs_ptr, void *data)
 VALUE
 rb_vm_cc_table_dup(VALUE old_table)
 {
+    ASSERT_vm_locking();
     VALUE new_table = rb_vm_cc_table_create(rb_managed_id_table_size(old_table));
     rb_managed_id_table_foreach(old_table, vm_cc_table_dup_i, (void *)new_table);
     return new_table;
@@ -184,19 +196,20 @@ vm_ccs_invalidate(struct rb_class_cc_entries *ccs)
     }
 }
 
-void
+static void
 rb_vm_ccs_invalidate_and_free(struct rb_class_cc_entries *ccs)
 {
     RB_DEBUG_COUNTER_INC(ccs_free);
     vm_ccs_invalidate(ccs);
-    ruby_xfree(ccs);
+    ruby_xfree_sized(ccs, vm_ccs_alloc_size(ccs->capa));
 }
 
 void
 rb_vm_cc_table_delete(VALUE table, ID mid)
 {
-    struct rb_class_cc_entries *ccs;
-    if (rb_managed_id_table_lookup(table, mid, (VALUE *)&ccs)) {
+    VALUE ccs_obj;
+    if (rb_managed_id_table_lookup(table, mid, &ccs_obj)) {
+        struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_obj;
         rb_managed_id_table_delete(table, mid);
         rb_vm_ccs_invalidate_and_free(ccs);
     }
@@ -312,16 +325,13 @@ rb_clear_constant_cache_for_id_i(st_data_t ic, st_data_t arg)
     return ST_CONTINUE;
 }
 
-// Here for backward compat.
-void rb_clear_constant_cache(void) {}
-
 void
 rb_clear_constant_cache_for_id(ID id)
 {
     VALUE lookup_result;
     rb_vm_t *vm = GET_VM();
 
-    if (rb_id_table_lookup(vm->constant_cache, id, &lookup_result)) {
+    if (rb_id_table_lookup(&vm->constant_cache, id, &lookup_result)) {
         set_table *ics = (set_table *)lookup_result;
         set_table_foreach(ics, rb_clear_constant_cache_for_id_i, (st_data_t) NULL);
         ruby_vm_constant_cache_invalidations += ics->num_entries;
@@ -337,8 +347,8 @@ invalidate_negative_cache(ID mid)
     VALUE cme;
     rb_vm_t *vm = GET_VM();
 
-    if (rb_id_table_lookup(vm->negative_cme_table, mid, &cme)) {
-        rb_id_table_delete(vm->negative_cme_table, mid);
+    if (rb_id_table_lookup(&vm->negative_cme_table, mid, &cme)) {
+        rb_id_table_delete(&vm->negative_cme_table, mid);
         vm_cme_invalidate((rb_callable_method_entry_t *)cme);
         RB_DEBUG_COUNTER_INC(cc_invalidate_negative);
     }
@@ -355,6 +365,7 @@ invalidate_method_cache_in_cc_table(VALUE tbl, ID mid)
     if (tbl && rb_managed_id_table_lookup(tbl, mid, &ccs_data)) {
         struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_data;
         rb_yjit_cme_invalidate((rb_callable_method_entry_t *)ccs->cme);
+        rb_zjit_cme_invalidate((rb_callable_method_entry_t *)ccs->cme);
         if (NIL_P(ccs->cme->owner)) invalidate_negative_cache(mid);
         rb_vm_ccs_invalidate_and_free(ccs);
         rb_managed_id_table_delete(tbl, mid);
@@ -367,9 +378,8 @@ invalidate_callable_method_entry_in_callable_m_table(struct rb_id_table *tbl, ID
 {
     VALUE cme;
     if (tbl && rb_id_table_lookup(tbl, mid, &cme)) {
-        if (rb_yjit_enabled_p) {
-            rb_yjit_cme_invalidate((rb_callable_method_entry_t *)cme);
-        }
+        rb_yjit_cme_invalidate((rb_callable_method_entry_t *)cme);
+        rb_zjit_cme_invalidate((rb_callable_method_entry_t *)cme);
         rb_id_table_delete(tbl, mid);
         RB_DEBUG_COUNTER_INC(cc_invalidate_leaf_callable);
     }
@@ -383,7 +393,7 @@ struct invalidate_callable_method_entry_foreach_arg {
 };
 
 static void
-invalidate_callable_method_entry_in_every_m_table_i(rb_classext_t *ext, bool is_prime, VALUE namespace, void *data)
+invalidate_callable_method_entry_in_every_m_table_i(rb_classext_t *ext, bool is_prime, VALUE box_value, void *data)
 {
     st_data_t me;
     struct invalidate_callable_method_entry_foreach_arg *arg = (struct invalidate_callable_method_entry_foreach_arg *)data;
@@ -394,6 +404,30 @@ invalidate_callable_method_entry_in_every_m_table_i(rb_classext_t *ext, bool is_
     }
 }
 
+struct collect_per_box_origins_arg {
+    VALUE owner;
+    VALUE klass_housing_cme;
+    VALUE origins; // Array of origins
+};
+
+static void
+collect_per_box_origins_i(rb_classext_t *ext, bool is_prime, VALUE box_value, void *data)
+{
+    struct collect_per_box_origins_arg *arg = (struct collect_per_box_origins_arg *)data;
+    VALUE origin = RCLASSEXT_ORIGIN(ext);
+
+    if (origin == arg->owner || origin == arg->klass_housing_cme) {
+        return;
+    }
+    long len = RARRAY_LEN(arg->origins);
+    for (long i = 0; i < len; i++) {
+        if (RARRAY_AREF(arg->origins, i) == origin) {
+            return;
+        }
+    }
+    rb_ary_push(arg->origins, origin);
+}
+
 static void
 invalidate_callable_method_entry_in_every_m_table(VALUE klass, ID mid, const rb_callable_method_entry_t *cme)
 {
@@ -413,9 +447,8 @@ invalidate_complemented_method_entry_in_callable_m_table(struct rb_id_table *tbl
 {
     VALUE cme;
     if (tbl && rb_id_table_lookup(tbl, mid, &cme)) {
-        if (rb_yjit_enabled_p) {
-            rb_yjit_cme_invalidate((rb_callable_method_entry_t *)cme);
-        }
+        rb_yjit_cme_invalidate((rb_callable_method_entry_t *)cme);
+        rb_zjit_cme_invalidate((rb_callable_method_entry_t *)cme);
         rb_id_table_delete(tbl, mid);
         RB_DEBUG_COUNTER_INC(cc_invalidate_tree_callable);
     }
@@ -430,7 +463,12 @@ clear_method_cache_by_id_in_class(VALUE klass, ID mid)
     RB_VM_LOCKING() {
         rb_vm_barrier();
 
-        if (LIKELY(RCLASS_SUBCLASSES_FIRST(klass) == NULL)) {
+        if (LIKELY(!RCLASS_SUBCLASSES(klass)) &&
+            !FL_TEST_RAW(klass, RCLASS_HAS_SUBCLASSES) &&
+            // Non-refinement ICLASSes (from module inclusion) previously had
+            // subclasses reparented onto them, so they need the tree path for
+            // broader cme-based invalidation even though they now have no subclasses.
+            !(RB_TYPE_P(klass, T_ICLASS) && NIL_P(RCLASS_REFINED_CLASS(klass)))) {
             // no subclasses
             // check only current class
 
@@ -473,6 +511,29 @@ clear_method_cache_by_id_in_class(VALUE klass, ID mid)
 
                         // replace the cme that will be invalid in the all classexts
                         invalidate_callable_method_entry_in_every_m_table(klass_housing_cme, mid, cme);
+                        // owner may be a boxable class with per-box classext copies of its m_tbl
+                        // (klass_housing_cme may be a non-boxable origin ICLASS that doesn't cover them)
+                        if (klass_housing_cme != owner) {
+                            invalidate_callable_method_entry_in_every_m_table(owner, mid, cme);
+                        }
+                        // Also update per-box origin ICLASSes. When ensure_origin is called in
+                        // one box's context, it creates a per-box origin ICLASS whose m_tbl is
+                        // a copy of owner's m_tbl at that time. The current execution box may
+                        // not see these origins via RCLASS_ORIGIN(owner), so we find them by
+                        // iterating all of owner's classexts and checking their origin_ fields.
+                        {
+                            VALUE origins = rb_ary_hidden_new(1);
+                            struct collect_per_box_origins_arg origins_arg = {
+                                .owner = owner,
+                                .klass_housing_cme = klass_housing_cme,
+                                .origins = origins,
+                            };
+                            rb_class_classext_foreach(owner, collect_per_box_origins_i, &origins_arg);
+                            for (long i = 0; i < RARRAY_LEN(origins); i++) {
+                                invalidate_callable_method_entry_in_every_m_table(RARRAY_AREF(origins, i), mid, cme);
+                            }
+                            RB_GC_GUARD(origins);
+                        }
                     }
 
                     vm_cme_invalidate((rb_callable_method_entry_t *)cme);
@@ -511,7 +572,7 @@ clear_method_cache_by_id_in_class(VALUE klass, ID mid)
             }
         }
 
-        rb_gccct_clear_table(Qnil);
+        rb_gccct_clear_table();
     }
 }
 
@@ -563,6 +624,7 @@ invalidate_ccs_in_iclass_cc_tbl(VALUE value, void *data)
 {
     struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)value;
     vm_cme_invalidate((rb_callable_method_entry_t *)ccs->cme);
+    ruby_xfree_sized(ccs, vm_ccs_alloc_size(ccs->capa));
     return ID_TABLE_DELETE;
 }
 
@@ -577,32 +639,6 @@ rb_invalidate_method_caches(struct rb_id_table *cm_tbl, VALUE cc_tbl)
     }
 }
 
-static int
-invalidate_cc_refinement(st_data_t key, st_data_t data)
-{
-    VALUE v = (VALUE)key;
-    void *ptr = rb_asan_poisoned_object_p(v);
-    rb_asan_unpoison_object(v, false);
-
-    if (rb_gc_pointer_to_heap_p(v) &&
-        !rb_objspace_garbage_object_p(v) &&
-        RBASIC(v)->flags) { // liveness check
-        const struct rb_callcache *cc = (const struct rb_callcache *)v;
-
-        VM_ASSERT(vm_cc_refinement_p(cc));
-
-        if (vm_cc_valid(cc)) {
-            vm_cc_invalidate(cc);
-        }
-    }
-
-    if (ptr) {
-        rb_asan_poison_object(v);
-    }
-
-    return ST_CONTINUE;
-}
-
 static st_index_t
 vm_ci_hash(VALUE v)
 {
@@ -679,17 +715,16 @@ rb_vm_ci_lookup(ID mid, unsigned int flag, unsigned int argc, const struct rb_ca
     const struct rb_callinfo *ci = NULL;
 
     if (kwarg) {
-        ((struct rb_callinfo_kwarg *)kwarg)->references++;
+        RUBY_ATOMIC_FETCH_ADD(((struct rb_callinfo_kwarg *)kwarg)->references, 1);
     }
 
-    struct rb_callinfo *new_ci = IMEMO_NEW(struct rb_callinfo, imemo_callinfo, (VALUE)kwarg);
+    struct rb_callinfo *new_ci = SHAREABLE_IMEMO_NEW(struct rb_callinfo, imemo_callinfo, (VALUE)kwarg);
     new_ci->mid = mid;
     new_ci->flag = flag;
     new_ci->argc = argc;
 
     RB_VM_LOCKING() {
-        st_table *ci_table = vm->ci_table;
-        VM_ASSERT(ci_table);
+        st_table *ci_table = &vm->ci_table;
 
         do {
             st_update(ci_table, (st_data_t)new_ci, ci_lookup_i, (st_data_t)&ci);
@@ -709,31 +744,97 @@ rb_vm_ci_free(const struct rb_callinfo *ci)
     rb_vm_t *vm = GET_VM();
 
     st_data_t key = (st_data_t)ci;
-    st_delete(vm->ci_table, &key, NULL);
+    st_delete(&vm->ci_table, &key, NULL);
 }
 
-void
-rb_vm_insert_cc_refinement(const struct rb_callcache *cc)
+struct cc_refinement_entries {
+    VALUE *entries;
+    size_t len;
+    size_t capa;
+};
+
+static void
+cc_refinement_set_free(void *ptr)
 {
-    st_data_t key = (st_data_t)cc;
+    struct cc_refinement_entries *e = ptr;
+    xfree(e->entries);
+}
 
-    rb_vm_t *vm = GET_VM();
-    RB_VM_LOCK_ENTER();
-    {
-        rb_set_insert(vm->cc_refinement_table, key);
+static size_t
+cc_refinement_set_memsize(const void *ptr)
+{
+    const struct cc_refinement_entries *e = ptr;
+    return e->capa * sizeof(VALUE);
+}
+
+static void
+cc_refinement_set_compact(void *ptr)
+{
+    struct cc_refinement_entries *e = ptr;
+    for (size_t i = 0; i < e->len; i++) {
+        e->entries[i] = rb_gc_location(e->entries[i]);
     }
-    RB_VM_LOCK_LEAVE();
 }
 
-void
-rb_vm_delete_cc_refinement(const struct rb_callcache *cc)
+static void
+cc_refinement_set_handle_weak_references(void *ptr)
 {
-    ASSERT_vm_locking();
+    struct cc_refinement_entries *e = ptr;
+    size_t write = 0;
+    for (size_t read = 0; read < e->len; read++) {
+        if (rb_gc_handle_weak_references_alive_p(e->entries[read])) {
+            e->entries[write++] = e->entries[read];
+        }
+    }
+    e->len = write;
+}
+
+static const rb_data_type_t cc_refinement_set_type = {
+    "VM/cc_refinement_set",
+    {
+        NULL,
+        cc_refinement_set_free,
+        cc_refinement_set_memsize,
+        cc_refinement_set_compact,
+        cc_refinement_set_handle_weak_references,
+    },
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE
+};
+
+VALUE
+rb_cc_refinement_set_create(void)
+{
+    struct cc_refinement_entries *e;
+    VALUE obj = TypedData_Make_Struct(0, struct cc_refinement_entries, &cc_refinement_set_type, e);
+
+    e->entries = NULL;
+    e->len = 0;
+    e->capa = 0;
+
+    rb_gc_declare_weak_references(obj);
 
+    return obj;
+}
+
+void
+rb_vm_insert_cc_refinement(const struct rb_callcache *cc)
+{
     rb_vm_t *vm = GET_VM();
-    st_data_t key = (st_data_t)cc;
+    RB_VM_LOCK_ENTER();
+    {
+        struct cc_refinement_entries *e = RTYPEDDATA_GET_DATA(vm->cc_refinement_set);
+        if (e->len == e->capa) {
+            size_t new_capa = e->capa == 0 ? 16 : e->capa * 2;
+            SIZED_REALLOC_N(e->entries, VALUE, new_capa, e->capa);
+            e->capa = new_capa;
+        }
+        e->entries[e->len++] = (VALUE)cc;
 
-    rb_set_table_delete(vm->cc_refinement_table, &key);
+        // We never mark the cc, but we need to issue a writebarrier so that
+        // the refinement set can be added to the remembered set
+        RB_OBJ_WRITTEN(vm->cc_refinement_set, Qundef, (VALUE)cc);
+    }
+    RB_VM_LOCK_LEAVE();
 }
 
 void
@@ -743,9 +844,23 @@ rb_clear_all_refinement_method_cache(void)
 
     RB_VM_LOCK_ENTER();
     {
-        rb_set_table_foreach(vm->cc_refinement_table, invalidate_cc_refinement, (st_data_t)NULL);
-        rb_set_table_clear(vm->cc_refinement_table);
-        rb_set_compact_table(vm->cc_refinement_table);
+        struct cc_refinement_entries *e = RTYPEDDATA_GET_DATA(vm->cc_refinement_set);
+        for (size_t i = 0; i < e->len; i++) {
+            VALUE v = e->entries[i];
+
+            // All objects should be live as weak references are pruned in
+            // cc_refinement_set_handle_weak_references
+            VM_ASSERT(rb_gc_pointer_to_heap_p(v));
+            VM_ASSERT(!rb_objspace_garbage_object_p(v));
+
+            const struct rb_callcache *cc = (const struct rb_callcache *)v;
+            VM_ASSERT(vm_cc_refinement_p(cc));
+
+            if (vm_cc_valid(cc)) {
+                vm_cc_invalidate(cc);
+            }
+        }
+        e->len = 0;
     }
     RB_VM_LOCK_LEAVE();
 
@@ -755,7 +870,9 @@ rb_clear_all_refinement_method_cache(void)
 void
 rb_method_table_insert(VALUE klass, struct rb_id_table *table, ID method_id, const rb_method_entry_t *me)
 {
-    rb_method_table_insert0(klass, table, method_id, me, RB_TYPE_P(klass, T_ICLASS) && !RICLASS_OWNS_M_TBL_P(klass));
+    RB_VM_LOCKING() {
+        rb_method_table_insert0(klass, table, method_id, me, RB_TYPE_P(klass, T_ICLASS) && !RICLASS_OWNS_M_TBL_P(klass));
+    }
 }
 
 void
@@ -823,7 +940,7 @@ rb_add_method_optimized(VALUE klass, ID mid, enum method_optimized_type opt_type
 }
 
 static void
-rb_method_definition_release(rb_method_definition_t *def)
+method_definition_release(rb_method_definition_t *def)
 {
     if (def != NULL) {
         const unsigned int reference_count_was = RUBY_ATOMIC_FETCH_SUB(def->reference_count, 1);
@@ -833,10 +950,7 @@ rb_method_definition_release(rb_method_definition_t *def)
         if (reference_count_was == 1) {
             if (METHOD_DEBUG) fprintf(stderr, "-%p-%s:1->0 (remove)\n", (void *)def,
                                       rb_id2name(def->original_id));
-            if (def->type == VM_METHOD_TYPE_BMETHOD && def->body.bmethod.hooks) {
-                xfree(def->body.bmethod.hooks);
-            }
-            xfree(def);
+            SIZED_FREE(def);
         }
         else {
             if (METHOD_DEBUG) fprintf(stderr, "-%p-%s:%d->%d (dec)\n", (void *)def, rb_id2name(def->original_id),
@@ -845,6 +959,12 @@ rb_method_definition_release(rb_method_definition_t *def)
     }
 }
 
+void
+rb_method_definition_release(rb_method_definition_t *def)
+{
+    method_definition_release(def);
+}
+
 static void delete_overloaded_cme(const rb_callable_method_entry_t *cme);
 
 void
@@ -858,7 +978,18 @@ rb_free_method_entry_vm_weak_references(const rb_method_entry_t *me)
 void
 rb_free_method_entry(const rb_method_entry_t *me)
 {
-    rb_method_definition_release(me->def);
+#if USE_ZJIT
+    if (METHOD_ENTRY_CACHED(me)) {
+        rb_zjit_cme_free((const rb_callable_method_entry_t *)me);
+    }
+#endif
+
+#if USE_YJIT
+    // YJIT rb_yjit_root_mark() roots CMEs in `Invariants`,
+    // to remove from `Invariants` here.
+#endif
+
+    method_definition_release(me->def);
 }
 
 static inline rb_method_entry_t *search_method(VALUE klass, ID id, VALUE *defined_class_ptr);
@@ -925,6 +1056,7 @@ setup_method_cfunc_struct(rb_method_cfunc_t *cfunc, VALUE (*func)(ANYARGS), int
     cfunc->invoker = call_cfunc_invoker_func(argc);
 }
 
+
 static rb_method_definition_t *
 method_definition_addref(rb_method_definition_t *def, bool complemented)
 {
@@ -939,9 +1071,15 @@ method_definition_addref(rb_method_definition_t *def, bool complemented)
 }
 
 void
+rb_method_definition_addref(rb_method_definition_t *def)
+{
+    method_definition_addref(def, false);
+}
+
+void
 rb_method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *def, void *opts)
 {
-    rb_method_definition_release(me->def);
+    method_definition_release(me->def);
     *(rb_method_definition_t **)&me->def = method_definition_addref(def, METHOD_ENTRY_COMPLEMENTED(me));
 
     if (!ruby_running) add_opt_method_entry(me);
@@ -994,8 +1132,10 @@ rb_method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *de
                 cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
 
                 if (cfp && (line = rb_vm_get_sourceline(cfp))) {
-                    VALUE location = rb_ary_new3(2, rb_iseq_path(cfp->iseq), INT2FIX(line));
-                    RB_OBJ_WRITE(me, &def->body.attr.location, rb_ary_freeze(location));
+                    VALUE location = rb_ary_new3(2, rb_iseq_path(CFP_ISEQ(cfp)), INT2FIX(line));
+                    rb_ary_freeze(location);
+                    RB_OBJ_SET_SHAREABLE(location);
+                    RB_OBJ_WRITE(me, &def->body.attr.location, location);
                 }
                 else {
                     VM_ASSERT(def->body.attr.location == 0);
@@ -1004,7 +1144,7 @@ rb_method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *de
             }
           case VM_METHOD_TYPE_BMETHOD:
             RB_OBJ_WRITE(me, &def->body.bmethod.proc, (VALUE)opts);
-            RB_OBJ_WRITE(me, &def->body.bmethod.defined_ractor, rb_ractor_self(GET_RACTOR()));
+            def->body.bmethod.defined_ractor_id = rb_ec_ractor_id(GET_EC());
             return;
           case VM_METHOD_TYPE_NOTIMPLEMENTED:
             setup_method_cfunc_struct(UNALIGNED_MEMBER_PTR(def, body.cfunc), (VALUE(*)(ANYARGS))rb_f_notimplement_internal, -1);
@@ -1044,9 +1184,6 @@ method_definition_reset(const rb_method_entry_t *me)
         break;
       case VM_METHOD_TYPE_BMETHOD:
         RB_OBJ_WRITTEN(me, Qundef, def->body.bmethod.proc);
-        RB_OBJ_WRITTEN(me, Qundef, def->body.bmethod.defined_ractor);
-        /* give up to check all in a list */
-        if (def->body.bmethod.hooks) rb_gc_writebarrier_remember((VALUE)me);
         break;
       case VM_METHOD_TYPE_REFINED:
         RB_OBJ_WRITTEN(me, Qundef, def->body.refined.orig_me);
@@ -1074,7 +1211,7 @@ rb_method_definition_create(rb_method_type_t type, ID mid)
     def->type = type;
     def->original_id = mid;
     def->method_serial = (uintptr_t)RUBY_ATOMIC_FETCH_ADD(method_serial, 1);
-    def->ns = rb_current_namespace();
+    def->box = rb_current_box();
     return def;
 }
 
@@ -1086,7 +1223,11 @@ rb_method_entry_alloc(ID called_id, VALUE owner, VALUE defined_class, rb_method_
         // not negative cache
         VM_ASSERT_TYPE2(defined_class, T_CLASS, T_ICLASS);
     }
-    rb_method_entry_t *me = IMEMO_NEW(rb_method_entry_t, imemo_ment, defined_class);
+    rb_method_entry_t *me = SHAREABLE_IMEMO_NEW(rb_method_entry_t, imemo_ment, defined_class);
+
+    // mark_and_move_method_entry pins itself when it is in the overloaded_cme table
+    rb_gc_register_pinning_obj((VALUE)me);
+
     *((rb_method_definition_t **)&me->def) = def;
     me->called_id = called_id;
     me->owner = owner;
@@ -1180,7 +1321,7 @@ rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID cal
 void
 rb_method_entry_copy(rb_method_entry_t *dst, const rb_method_entry_t *src)
 {
-    rb_method_definition_release(dst->def);
+    method_definition_release(dst->def);
     *(rb_method_definition_t **)&dst->def = method_definition_addref(src->def, METHOD_ENTRY_COMPLEMENTED(src));
     method_definition_reset(dst);
     dst->called_id = src->called_id;
@@ -1245,6 +1386,16 @@ rb_add_refined_method_entry(VALUE refined_class, ID mid)
 static void
 check_override_opt_method_i(VALUE klass, VALUE arg)
 {
+    if (RB_TYPE_P(klass, T_ICLASS)) {
+        // ICLASS from a module's subclass list: check the includer and
+        // recurse into the includer's T_CLASS subclasses.
+        VALUE includer = RCLASS_INCLUDER(klass);
+        if (!UNDEF_P(includer) && includer) {
+            check_override_opt_method_i(includer, arg);
+        }
+        return;
+    }
+
     ID mid = (ID)arg;
     const rb_method_entry_t *me, *newme;
 
@@ -1266,6 +1417,13 @@ check_override_opt_method(VALUE klass, VALUE mid)
     }
 }
 
+VALUE
+rb_zsuper_to_super(int argc, VALUE *argv, VALUE self)
+{
+    return rb_call_super_kw(argc, argv, RB_PASS_CALLED_KEYWORDS);
+}
+
+static inline rb_method_entry_t* search_method0(VALUE klass, ID id, VALUE *defined_class_ptr, bool skip_refined);
 /*
  * klass->method_table[mid] = method_entry(defined_class, visi, def)
  *
@@ -1281,6 +1439,7 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
     st_data_t data;
     int make_refined = 0;
     VALUE orig_klass;
+    bool turn_zsuper_to_super = false;
 
     if (NIL_P(klass)) {
         klass = rb_cObject;
@@ -1306,6 +1465,9 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
 
     if (RB_TYPE_P(klass, T_MODULE) && FL_TEST(klass, RMODULE_IS_REFINEMENT)) {
         VALUE refined_class = rb_refinement_module_get_refined_class(klass);
+        if (type == VM_METHOD_TYPE_ZSUPER) {
+            turn_zsuper_to_super = true;
+        }
         rb_add_refined_method_entry(refined_class, mid);
     }
     if (type == VM_METHOD_TYPE_REFINED) {
@@ -1369,6 +1531,12 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
     me = rb_method_entry_create(mid, defined_class, visi, NULL);
     if (def == NULL) {
         def = rb_method_definition_create(type, original_id);
+        if (turn_zsuper_to_super) {
+          def->type = VM_METHOD_TYPE_CFUNC;
+          def->body.cfunc.func = (rb_cfunc_t)rb_zsuper_to_super;
+          def->body.cfunc.invoker = ractor_safe_call_cfunc_m1;
+          def->body.cfunc.argc = -1;
+        }
     }
     rb_method_definition_set(me, def, opts);
 
@@ -1410,8 +1578,7 @@ rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibil
 static st_table *
 overloaded_cme_table(void)
 {
-    VM_ASSERT(GET_VM()->overloaded_cme_table != NULL);
-    return GET_VM()->overloaded_cme_table;
+    return &GET_VM()->overloaded_cme_table;
 }
 
 #if VM_CHECK_MODE > 0
@@ -1546,7 +1713,9 @@ method_added(VALUE klass, ID mid)
 void
 rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *opts, rb_method_visibility_t visi)
 {
-    rb_method_entry_make(klass, mid, klass, visi, type, NULL, mid, opts);
+    RB_VM_LOCKING() {
+        rb_method_entry_make(klass, mid, klass, visi, type, NULL, mid, opts);
+    }
 
     if (type != VM_METHOD_TYPE_UNDEF && type != VM_METHOD_TYPE_REFINED) {
         method_added(klass, mid);
@@ -1571,11 +1740,14 @@ static rb_method_entry_t *
 method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *me,
                  rb_method_visibility_t visi, VALUE defined_class)
 {
-    rb_method_entry_t *newme = rb_method_entry_make(klass, mid, defined_class, visi,
-                                                    me->def->type, me->def, 0, NULL);
-    if (newme == me) {
-        me->def->no_redef_warning = TRUE;
-        METHOD_ENTRY_FLAGS_SET(newme, visi, FALSE);
+    rb_method_entry_t *newme;
+    RB_VM_LOCKING() {
+        newme = rb_method_entry_make(klass, mid, defined_class, visi,
+                me->def->type, me->def, 0, NULL);
+        if (newme == me) {
+            me->def->no_redef_warning = TRUE;
+            METHOD_ENTRY_FLAGS_SET(newme, visi, FALSE);
+        }
     }
 
     method_added(klass, mid);
@@ -1590,6 +1762,17 @@ rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *me, rb_method_
 
 #define UNDEF_ALLOC_FUNC ((rb_alloc_func_t)-1)
 
+static void
+propagate_alloc_func(VALUE subclass, VALUE arg)
+{
+    if (RB_TYPE_P(subclass, T_CLASS) &&
+        !RCLASS_SINGLETON_P(subclass) &&
+        !FL_TEST_RAW(subclass, RCLASS_ALLOCATOR_DEFINED)) {
+        RCLASS_SET_ALLOCATOR(subclass, (rb_alloc_func_t)arg);
+        rb_class_foreach_subclass(subclass, propagate_alloc_func, arg);
+    }
+}
+
 void
 rb_define_alloc_func(VALUE klass, VALUE (*func)(VALUE))
 {
@@ -1598,25 +1781,28 @@ rb_define_alloc_func(VALUE klass, VALUE (*func)(VALUE))
         rb_raise(rb_eTypeError, "can't define an allocator for a singleton class");
     }
     RCLASS_SET_ALLOCATOR(klass, func);
+    FL_SET_RAW(klass, RCLASS_ALLOCATOR_DEFINED);
+    rb_class_foreach_subclass(klass, propagate_alloc_func, (VALUE)func);
 }
 
 void
 rb_undef_alloc_func(VALUE klass)
 {
-    rb_define_alloc_func(klass, UNDEF_ALLOC_FUNC);
+    Check_Type(klass, T_CLASS);
+    RCLASS_SET_ALLOCATOR(klass, UNDEF_ALLOC_FUNC);
+    FL_SET_RAW(klass, RCLASS_ALLOCATOR_DEFINED);
+    rb_class_foreach_subclass(klass, propagate_alloc_func, (VALUE)UNDEF_ALLOC_FUNC);
 }
 
 rb_alloc_func_t
 rb_get_alloc_func(VALUE klass)
 {
-    Check_Type(klass, T_CLASS);
+    RBIMPL_ASSERT_TYPE(klass, T_CLASS);
 
-    for (; klass; klass = RCLASS_SUPER(klass)) {
-        rb_alloc_func_t allocator = RCLASS_ALLOCATOR(klass);
-        if (allocator == UNDEF_ALLOC_FUNC) break;
-        if (allocator) return allocator;
-    }
-    return 0;
+    rb_alloc_func_t allocator = RCLASS_ALLOCATOR(klass);
+    if (allocator == UNDEF_ALLOC_FUNC) return 0;
+    RUBY_ASSERT(allocator);
+    return allocator;
 }
 
 const rb_method_entry_t *
@@ -1804,12 +1990,12 @@ negative_cme(ID mid)
     const rb_callable_method_entry_t *cme;
     VALUE cme_data;
 
-    if (rb_id_table_lookup(vm->negative_cme_table, mid, &cme_data)) {
+    if (rb_id_table_lookup(&vm->negative_cme_table, mid, &cme_data)) {
         cme = (rb_callable_method_entry_t *)cme_data;
     }
     else {
         cme = (rb_callable_method_entry_t *)rb_method_entry_alloc(mid, Qnil, Qnil, NULL, false);
-        rb_id_table_insert(vm->negative_cme_table, mid, (VALUE)cme);
+        rb_id_table_insert(&vm->negative_cme_table, mid, (VALUE)cme);
     }
 
     VM_ASSERT(cme != NULL);
@@ -1985,7 +2171,12 @@ resolve_refined_method(VALUE refinements, const rb_method_entry_t *me, VALUE *de
 
         tmp_me = me->def->body.refined.orig_me;
         if (tmp_me) {
-            if (defined_class_ptr) *defined_class_ptr = tmp_me->defined_class;
+            if (!tmp_me->defined_class) {
+                VM_ASSERT_TYPE(tmp_me->owner, T_MODULE);
+            }
+            else if (defined_class_ptr) {
+                *defined_class_ptr = tmp_me->defined_class;
+            }
             return tmp_me;
         }
 
@@ -2198,7 +2389,7 @@ scope_visibility_check(void)
 {
     /* Check for public/protected/private/module_function called inside a method */
     rb_control_frame_t *cfp = GET_EC()->cfp+1;
-    if (cfp && cfp->iseq && ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_METHOD) {
+    if (cfp && CFP_ISEQ(cfp) && ISEQ_BODY(CFP_ISEQ(cfp))->type == ISEQ_TYPE_METHOD) {
         rb_warn("calling %s without arguments inside a method may not have the intended effect",
             rb_id2name(rb_frame_this_func()));
     }