Use the shape_id rather than FL_EXIVAR

We still keep setting `FL_EXIVAR` so that `rb_shape_verify_consistency`
can detect discrepancies.

Author: byroot

gc.c

@@ -2070,7 +2070,7 @@ rb_gc_obj_free_vm_weak_references(VALUE obj)
 {
     obj_free_object_id(obj);
 
-    if (FL_TEST_RAW(obj, FL_EXIVAR)) {
+    if (rb_obj_exivar_p(obj)) {
         rb_free_generic_ivar((VALUE)obj);
     }
 
@@ -2316,7 +2316,7 @@ rb_obj_memsize_of(VALUE obj)
         return 0;
     }
 
-    if (FL_TEST(obj, FL_EXIVAR)) {
+    if (rb_obj_exivar_p(obj)) {
         size += rb_generic_ivar_memsize(obj);
     }
 
@@ -3141,7 +3141,7 @@ rb_gc_mark_children(void *objspace, VALUE obj)
 {
     struct gc_mark_classext_foreach_arg foreach_args;
 
-    if (FL_TEST_RAW(obj, FL_EXIVAR)) {
+    if (rb_obj_exivar_p(obj)) {
         rb_mark_generic_ivar(obj);
     }
 
@@ -4012,6 +4012,7 @@ vm_weak_table_gen_fields_foreach(st_data_t key, st_data_t value, st_data_t data)
         free_gen_fields_tbl((VALUE)key, (struct gen_fields_tbl *)value);
 
         FL_UNSET((VALUE)key, FL_EXIVAR);
+        RBASIC_SET_SHAPE_ID((VALUE)key, ROOT_SHAPE_ID);
         return ST_DELETE;
 
       case ST_REPLACE: {

hash.c

@@ -1597,10 +1597,11 @@ VALUE
 rb_hash_dup(VALUE hash)
 {
     const VALUE flags = RBASIC(hash)->flags;
-    VALUE ret = hash_dup(hash, rb_obj_class(hash),
-                         flags & (FL_EXIVAR|RHASH_PROC_DEFAULT));
-    if (flags & FL_EXIVAR)
+    VALUE ret = hash_dup(hash, rb_obj_class(hash), flags & RHASH_PROC_DEFAULT);
+
+    if (rb_obj_exivar_p(hash)) {
         rb_copy_generic_ivar(ret, hash);
+    }
     return ret;
 }
 
@@ -2920,7 +2921,7 @@ hash_aset(st_data_t *key, st_data_t *val, struct update_arg *arg, int existing)
 VALUE
 rb_hash_key_str(VALUE key)
 {
-    if (!RB_FL_ANY_RAW(key, FL_EXIVAR) && RBASIC_CLASS(key) == rb_cString) {
+    if (!rb_obj_exivar_p(key) && RBASIC_CLASS(key) == rb_cString) {
         return rb_fstring(key);
     }
     else {

object.c

@@ -373,9 +373,9 @@ init_copy(VALUE dest, VALUE obj)
     if (OBJ_FROZEN(dest)) {
         rb_raise(rb_eTypeError, "[bug] frozen object (%s) allocated", rb_obj_classname(dest));
     }
-    RBASIC(dest)->flags &= ~(T_MASK|FL_EXIVAR);
+    RBASIC(dest)->flags &= ~T_MASK;
     // Copies the shape id from obj to dest
-    RBASIC(dest)->flags |= RBASIC(obj)->flags & (T_MASK|FL_EXIVAR);
+    RBASIC(dest)->flags |= RBASIC(obj)->flags & T_MASK;
     switch (BUILTIN_TYPE(obj)) {
         case T_IMEMO:
           rb_bug("Unreacheable");

ractor.c

@@ -1656,7 +1656,7 @@ obj_traverse_replace_i(VALUE obj, struct obj_traverse_replace_data *data)
     else if (data->replacement != _val)     { RB_OBJ_WRITE(obj, &v, data->replacement); } \
 } while (0)
 
-    if (UNLIKELY(FL_TEST_RAW(obj, FL_EXIVAR))) {
+    if (UNLIKELY(rb_obj_exivar_p(obj))) {
         struct gen_fields_tbl *fields_tbl;
         rb_ivar_generic_fields_tbl_lookup(obj, &fields_tbl);
 
@@ -1885,7 +1885,7 @@ move_leave(VALUE obj, struct obj_traverse_replace_data *data)
 
     rb_gc_obj_id_moved(data->replacement);
 
-    if (UNLIKELY(FL_TEST_RAW(obj, FL_EXIVAR))) {
+    if (UNLIKELY(rb_obj_exivar_p(obj))) {
         rb_replace_generic_ivar(data->replacement, obj);
     }
 

shape.c

@@ -1267,10 +1267,10 @@ rb_shape_verify_consistency(VALUE obj, shape_id_t shape_id)
     }
 
     if (FL_TEST_RAW(obj, FL_EXIVAR)) {
-        RUBY_ASSERT(rb_obj_has_exivar(obj));
+        RUBY_ASSERT(rb_obj_exivar_p(obj));
     }
     else {
-        RUBY_ASSERT(!rb_obj_has_exivar(obj));
+        RUBY_ASSERT(!rb_obj_exivar_p(obj));
     }
 
     return true;

shape.h

@@ -355,7 +355,7 @@ rb_shape_obj_has_fields(VALUE obj)
 }
 
 static inline bool
-rb_obj_has_exivar(VALUE obj)
+rb_obj_exivar_p(VALUE obj)
 {
     switch (TYPE(obj)) {
         case T_NONE:

string.c

@@ -486,6 +486,7 @@ build_fstring(VALUE str, struct fstr_update_arg *arg)
     RUBY_ASSERT(OBJ_FROZEN(str));
     RUBY_ASSERT(!FL_TEST_RAW(str, STR_FAKESTR));
     RUBY_ASSERT(!FL_TEST_RAW(str, FL_EXIVAR));
+    RUBY_ASSERT(!rb_obj_exivar_p(str));
     RUBY_ASSERT(RBASIC_CLASS(str) == rb_cString);
     RUBY_ASSERT(!rb_objspace_garbage_object_p(str));
 

variable.c

@@ -1255,22 +1255,25 @@ rb_mark_generic_ivar(VALUE obj)
 void
 rb_free_generic_ivar(VALUE obj)
 {
-    st_data_t key = (st_data_t)obj, value;
+    if (rb_obj_exivar_p(obj)) {
+        st_data_t key = (st_data_t)obj, value;
 
-    bool too_complex = rb_shape_obj_too_complex_p(obj);
+        bool too_complex = rb_shape_obj_too_complex_p(obj);
 
-    RB_VM_LOCKING() {
-        if (st_delete(generic_fields_tbl_no_ractor_check(obj), &key, &value)) {
-            struct gen_fields_tbl *fields_tbl = (struct gen_fields_tbl *)value;
+        RB_VM_LOCKING() {
+            if (st_delete(generic_fields_tbl_no_ractor_check(obj), &key, &value)) {
+                struct gen_fields_tbl *fields_tbl = (struct gen_fields_tbl *)value;
 
-            if (UNLIKELY(too_complex)) {
-                st_free_table(fields_tbl->as.complex.table);
-            }
+                if (UNLIKELY(too_complex)) {
+                    st_free_table(fields_tbl->as.complex.table);
+                }
 
-            xfree(fields_tbl);
+                xfree(fields_tbl);
+            }
         }
+        FL_UNSET_RAW(obj, FL_EXIVAR);
+        RBASIC_SET_SHAPE_ID(obj, ROOT_SHAPE_ID);
     }
-    FL_UNSET_RAW(obj, FL_EXIVAR);
 }
 
 size_t
@@ -1327,6 +1330,7 @@ rb_obj_field_get(VALUE obj, shape_id_t target_shape_id)
             break;
           default:
             RUBY_ASSERT(FL_TEST_RAW(obj, FL_EXIVAR));
+            RUBY_ASSERT(rb_obj_exivar_p(obj));
             struct gen_fields_tbl *fields_tbl = NULL;
             rb_ivar_generic_fields_tbl_lookup(obj, &fields_tbl);
             RUBY_ASSERT(fields_tbl);
@@ -1358,6 +1362,7 @@ rb_obj_field_get(VALUE obj, shape_id_t target_shape_id)
         break;
       default:
         RUBY_ASSERT(FL_TEST_RAW(obj, FL_EXIVAR));
+        RUBY_ASSERT(rb_obj_exivar_p(obj));
         struct gen_fields_tbl *fields_tbl = NULL;
         rb_ivar_generic_fields_tbl_lookup(obj, &fields_tbl);
         RUBY_ASSERT(fields_tbl);
@@ -1435,7 +1440,7 @@ rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
         }
       default:
         shape_id = RBASIC_SHAPE_ID(obj);
-        if (FL_TEST_RAW(obj, FL_EXIVAR)) {
+        if (rb_obj_exivar_p(obj)) {
             struct gen_fields_tbl *fields_tbl;
             rb_gen_fields_tbl_get(obj, id, &fields_tbl);
 
@@ -1551,22 +1556,20 @@ rb_ivar_delete(VALUE obj, ID id, VALUE undef)
         size_t trailing_fields = new_fields_count - removed_index;
 
         MEMMOVE(&fields[removed_index], &fields[removed_index + 1], VALUE, trailing_fields);
-
-        if (RB_TYPE_P(obj, T_OBJECT) &&
-            !RB_FL_TEST_RAW(obj, ROBJECT_EMBED) &&
-            rb_obj_embedded_size(new_fields_count) <= rb_gc_obj_slot_size(obj)) {
-            // Re-embed objects when instances become small enough
-            // This is necessary because YJIT assumes that objects with the same shape
-            // have the same embeddedness for efficiency (avoid extra checks)
-            RB_FL_SET_RAW(obj, ROBJECT_EMBED);
-            MEMCPY(ROBJECT_FIELDS(obj), fields, VALUE, new_fields_count);
-            xfree(fields);
-        }
     }
     else {
-        if (FL_TEST_RAW(obj, FL_EXIVAR)) {
-            rb_free_generic_ivar(obj);
-        }
+        rb_free_generic_ivar(obj);
+    }
+
+    if (RB_TYPE_P(obj, T_OBJECT) &&
+        !RB_FL_TEST_RAW(obj, ROBJECT_EMBED) &&
+        rb_obj_embedded_size(new_fields_count) <= rb_gc_obj_slot_size(obj)) {
+        // Re-embed objects when instances become small enough
+        // This is necessary because YJIT assumes that objects with the same shape
+        // have the same embeddedness for efficiency (avoid extra checks)
+        RB_FL_SET_RAW(obj, ROBJECT_EMBED);
+        MEMCPY(ROBJECT_FIELDS(obj), fields, VALUE, new_fields_count);
+        xfree(fields);
     }
     rb_obj_set_shape_id(obj, next_shape_id);
 
@@ -1844,13 +1847,14 @@ generic_fields_lookup_ensure_size(st_data_t *k, st_data_t *v, st_data_t u, int e
         *v = (st_data_t)fields_tbl;
     }
 
-    RUBY_ASSERT(FL_TEST((VALUE)*k, FL_EXIVAR));
-
     fields_lookup->fields_tbl = fields_tbl;
     if (fields_lookup->shape_id) {
         rb_obj_set_shape_id(fields_lookup->obj, fields_lookup->shape_id);
     }
 
+    RUBY_ASSERT(FL_TEST((VALUE)*k, FL_EXIVAR));
+    RUBY_ASSERT(rb_obj_exivar_p((VALUE)*k));
+
     return ST_CONTINUE;
 }
 
@@ -2349,8 +2353,8 @@ rb_copy_generic_ivar(VALUE dest, VALUE obj)
 
     rb_check_frozen(dest);
 
-    if (!FL_TEST(obj, FL_EXIVAR)) {
-        goto clear;
+    if (!rb_obj_exivar_p(obj)) {
+        return;
     }
 
     unsigned long src_num_ivs = rb_ivar_count(obj);
@@ -2414,11 +2418,7 @@ rb_copy_generic_ivar(VALUE dest, VALUE obj)
     return;
 
   clear:
-    if (FL_TEST(dest, FL_EXIVAR)) {
-        rb_free_generic_ivar(dest);
-        FL_UNSET(dest, FL_EXIVAR);
-        RBASIC_SET_SHAPE_ID(dest, ROOT_SHAPE_ID);
-    }
+    rb_free_generic_ivar(dest);
 }
 
 void
@@ -2464,7 +2464,7 @@ rb_field_foreach(VALUE obj, rb_ivar_foreach_callback_func *func, st_data_t arg,
         }
         break;
       default:
-        if (FL_TEST_RAW(obj, FL_EXIVAR)) {
+        if (rb_obj_exivar_p(obj)) {
             gen_fields_each(obj, func, arg, ivar_only);
         }
         break;
@@ -2500,7 +2500,7 @@ rb_ivar_count(VALUE obj)
             return RBASIC_FIELDS_COUNT(fields_obj);
         }
       default:
-        if (FL_TEST(obj, FL_EXIVAR)) {
+        if (rb_obj_exivar_p(obj)) {
             struct gen_fields_tbl *fields_tbl;
 
             if (rb_gen_fields_tbl_get(obj, 0, &fields_tbl)) {

vm_insnhelper.c

@@ -1258,7 +1258,7 @@ vm_getivar(VALUE obj, ID id, const rb_iseq_t *iseq, IVC ic, const struct rb_call
             break;
         }
       default:
-        if (FL_TEST_RAW(obj, FL_EXIVAR)) {
+        if (rb_obj_exivar_p(obj)) {
             struct gen_fields_tbl *fields_tbl;
             rb_gen_fields_tbl_get(obj, id, &fields_tbl);
             ivar_list = fields_tbl->as.shape.fields;