archive/ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2025-08-15 13:39:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Rename imemo_class_fields -> imemo_fields

Browse source
This commit is contained in:
Jean Boussier 2025-06-16 10:31:21 +02:00
parent 4cb0205f51
commit fb68721f63
Notes: git 2025-06-17 13:28:18 +00:00
12 changed files with 73 additions and 73 deletions
Download patch file Download diff file Expand all files Collapse all files

2
class.c
View file

@ -298,7 +298,7 @@ rb_class_duplicate_classext(rb_classext_t *orig, VALUE klass, const rb_namespace
RCLASSEXT_M_TBL(ext) = duplicate_classext_m_tbl(RCLASSEXT_M_TBL(orig), klass, dup_iclass); RCLASSEXT_M_TBL(ext) = duplicate_classext_m_tbl(RCLASSEXT_M_TBL(orig), klass, dup_iclass);
if (orig->fields_obj) { if (orig->fields_obj) {
RB_OBJ_WRITE(klass, &ext->fields_obj, rb_imemo_class_fields_clone(orig->fields_obj)); RB_OBJ_WRITE(klass, &ext->fields_obj, rb_imemo_fields_clone(orig->fields_obj));
} }
if (RCLASSEXT_SHARED_CONST_TBL(orig)) { if (RCLASSEXT_SHARED_CONST_TBL(orig)) {

2
debug_counter.h
View file

@ -315,7 +315,7 @@ RB_DEBUG_COUNTER(obj_imemo_parser_strterm)
RB_DEBUG_COUNTER(obj_imemo_callinfo) RB_DEBUG_COUNTER(obj_imemo_callinfo)
RB_DEBUG_COUNTER(obj_imemo_callcache) RB_DEBUG_COUNTER(obj_imemo_callcache)
RB_DEBUG_COUNTER(obj_imemo_constcache) RB_DEBUG_COUNTER(obj_imemo_constcache)
RB_DEBUG_COUNTER(obj_imemo_class_fields) RB_DEBUG_COUNTER(obj_imemo_fields)
RB_DEBUG_COUNTER(opt_new_hit) RB_DEBUG_COUNTER(opt_new_hit)
RB_DEBUG_COUNTER(opt_new_miss) RB_DEBUG_COUNTER(opt_new_miss)

2
ext/objspace/objspace.c
View file

@ -504,7 +504,7 @@ count_imemo_objects(int argc, VALUE *argv, VALUE self)
INIT_IMEMO_TYPE_ID(imemo_callinfo); INIT_IMEMO_TYPE_ID(imemo_callinfo);
INIT_IMEMO_TYPE_ID(imemo_callcache); INIT_IMEMO_TYPE_ID(imemo_callcache);
INIT_IMEMO_TYPE_ID(imemo_constcache); INIT_IMEMO_TYPE_ID(imemo_constcache);
INIT_IMEMO_TYPE_ID(imemo_class_fields); INIT_IMEMO_TYPE_ID(imemo_fields);
#undef INIT_IMEMO_TYPE_ID #undef INIT_IMEMO_TYPE_ID
} }

52
imemo.c
View file

@ -30,7 +30,7 @@ rb_imemo_name(enum imemo_type type)
IMEMO_NAME(svar); IMEMO_NAME(svar);
IMEMO_NAME(throw_data); IMEMO_NAME(throw_data);
IMEMO_NAME(tmpbuf); IMEMO_NAME(tmpbuf);
IMEMO_NAME(class_fields); IMEMO_NAME(fields);
#undef IMEMO_NAME #undef IMEMO_NAME
} }
rb_bug("unreachable"); rb_bug("unreachable");
@ -111,16 +111,16 @@ rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt)
} }
static VALUE static VALUE
imemo_class_fields_new(VALUE klass, size_t capa) imemo_fields_new(VALUE klass, size_t capa)
{ {
size_t embedded_size = offsetof(struct rb_class_fields, as.embed) + capa * sizeof(VALUE); size_t embedded_size = offsetof(struct rb_fields, as.embed) + capa * sizeof(VALUE);
if (rb_gc_size_allocatable_p(embedded_size)) { if (rb_gc_size_allocatable_p(embedded_size)) {
VALUE fields = rb_imemo_new(imemo_class_fields, klass, embedded_size); VALUE fields = rb_imemo_new(imemo_fields, klass, embedded_size);
RUBY_ASSERT(IMEMO_TYPE_P(fields, imemo_class_fields)); RUBY_ASSERT(IMEMO_TYPE_P(fields, imemo_fields));
return fields; return fields;
} }
else { else {
VALUE fields = rb_imemo_new(imemo_class_fields, klass, sizeof(struct rb_class_fields)); VALUE fields = rb_imemo_new(imemo_fields, klass, sizeof(struct rb_fields));
FL_SET_RAW(fields, OBJ_FIELD_EXTERNAL); FL_SET_RAW(fields, OBJ_FIELD_EXTERNAL);
IMEMO_OBJ_FIELDS(fields)->as.external.ptr = ALLOC_N(VALUE, capa); IMEMO_OBJ_FIELDS(fields)->as.external.ptr = ALLOC_N(VALUE, capa);
return fields; return fields;
@ -128,41 +128,41 @@ imemo_class_fields_new(VALUE klass, size_t capa)
} }
VALUE VALUE
rb_imemo_class_fields_new(VALUE klass, size_t capa) rb_imemo_fields_new(VALUE klass, size_t capa)
{ {
return imemo_class_fields_new(rb_singleton_class(klass), capa); return imemo_fields_new(rb_singleton_class(klass), capa);
} }
static VALUE static VALUE
imemo_class_fields_new_complex(VALUE klass, size_t capa) imemo_fields_new_complex(VALUE klass, size_t capa)
{ {
VALUE fields = imemo_class_fields_new(klass, sizeof(struct rb_class_fields)); VALUE fields = imemo_fields_new(klass, sizeof(struct rb_fields));
IMEMO_OBJ_FIELDS(fields)->as.complex.table = st_init_numtable_with_size(capa); IMEMO_OBJ_FIELDS(fields)->as.complex.table = st_init_numtable_with_size(capa);
return fields; return fields;
} }
VALUE VALUE
rb_imemo_class_fields_new_complex(VALUE klass, size_t capa) rb_imemo_fields_new_complex(VALUE klass, size_t capa)
{ {
return imemo_class_fields_new_complex(rb_singleton_class(klass), capa); return imemo_fields_new_complex(rb_singleton_class(klass), capa);
} }
VALUE VALUE
rb_imemo_class_fields_clone(VALUE fields_obj) rb_imemo_fields_clone(VALUE fields_obj)
{ {
shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj); shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);
VALUE clone; VALUE clone;
if (rb_shape_too_complex_p(shape_id)) { if (rb_shape_too_complex_p(shape_id)) {
clone = rb_imemo_class_fields_new_complex(CLASS_OF(fields_obj), 0); clone = rb_imemo_fields_new_complex(CLASS_OF(fields_obj), 0);
RBASIC_SET_SHAPE_ID(clone, shape_id); RBASIC_SET_SHAPE_ID(clone, shape_id);
st_table *src_table = rb_imemo_class_fields_complex_tbl(fields_obj); st_table *src_table = rb_imemo_fields_complex_tbl(fields_obj);
st_replace(rb_imemo_class_fields_complex_tbl(clone), src_table); st_replace(rb_imemo_fields_complex_tbl(clone), src_table);
} }
else { else {
clone = imemo_class_fields_new(CLASS_OF(fields_obj), RSHAPE_CAPACITY(shape_id)); clone = imemo_fields_new(CLASS_OF(fields_obj), RSHAPE_CAPACITY(shape_id));
RBASIC_SET_SHAPE_ID(clone, shape_id); RBASIC_SET_SHAPE_ID(clone, shape_id);
MEMCPY(rb_imemo_class_fields_ptr(clone), rb_imemo_class_fields_ptr(fields_obj), VALUE, RSHAPE_LEN(shape_id)); MEMCPY(rb_imemo_fields_ptr(clone), rb_imemo_fields_ptr(fields_obj), VALUE, RSHAPE_LEN(shape_id));
} }
return clone; return clone;
@ -215,7 +215,7 @@ rb_imemo_memsize(VALUE obj)
size += ((rb_imemo_tmpbuf_t *)obj)->cnt * sizeof(VALUE); size += ((rb_imemo_tmpbuf_t *)obj)->cnt * sizeof(VALUE);
break; break;
case imemo_class_fields: case imemo_fields:
if (rb_shape_obj_too_complex_p(obj)) { if (rb_shape_obj_too_complex_p(obj)) {
size += st_memsize(IMEMO_OBJ_FIELDS(obj)->as.complex.table); size += st_memsize(IMEMO_OBJ_FIELDS(obj)->as.complex.table);
} }
@ -487,11 +487,11 @@ rb_imemo_mark_and_move(VALUE obj, bool reference_updating)
break; break;
} }
case imemo_class_fields: { case imemo_fields: {
rb_gc_mark_and_move((VALUE *)&RBASIC(obj)->klass); rb_gc_mark_and_move((VALUE *)&RBASIC(obj)->klass);
if (rb_shape_obj_too_complex_p(obj)) { if (rb_shape_obj_too_complex_p(obj)) {
st_table *tbl = rb_imemo_class_fields_complex_tbl(obj); st_table *tbl = rb_imemo_fields_complex_tbl(obj);
if (reference_updating) { if (reference_updating) {
rb_gc_ref_update_table_values_only(tbl); rb_gc_ref_update_table_values_only(tbl);
} }
@ -500,7 +500,7 @@ rb_imemo_mark_and_move(VALUE obj, bool reference_updating)
} }
} }
else { else {
VALUE *fields = rb_imemo_class_fields_ptr(obj); VALUE *fields = rb_imemo_fields_ptr(obj);
attr_index_t len = RSHAPE_LEN(RBASIC_SHAPE_ID(obj)); attr_index_t len = RSHAPE_LEN(RBASIC_SHAPE_ID(obj));
for (attr_index_t i = 0; i < len; i++) { for (attr_index_t i = 0; i < len; i++) {
rb_gc_mark_and_move(&fields[i]); rb_gc_mark_and_move(&fields[i]);
@ -602,7 +602,7 @@ rb_cc_tbl_free(struct rb_id_table *cc_tbl, VALUE klass)
} }
static inline void static inline void
imemo_class_fields_free(struct rb_class_fields *fields) imemo_fields_free(struct rb_fields *fields)
{ {
if (rb_shape_obj_too_complex_p((VALUE)fields)) { if (rb_shape_obj_too_complex_p((VALUE)fields)) {
st_free_table(fields->as.complex.table); st_free_table(fields->as.complex.table);
@ -686,9 +686,9 @@ rb_imemo_free(VALUE obj)
RB_DEBUG_COUNTER_INC(obj_imemo_tmpbuf); RB_DEBUG_COUNTER_INC(obj_imemo_tmpbuf);
break; break;
case imemo_class_fields: case imemo_fields:
imemo_class_fields_free(IMEMO_OBJ_FIELDS(obj)); imemo_fields_free(IMEMO_OBJ_FIELDS(obj));
RB_DEBUG_COUNTER_INC(obj_imemo_class_fields); RB_DEBUG_COUNTER_INC(obj_imemo_fields);
break; break;
default: default:
rb_bug("unreachable"); rb_bug("unreachable");

4
internal/class.h
View file

@ -526,7 +526,7 @@ RCLASS_WRITABLE_ENSURE_FIELDS_OBJ(VALUE obj)
RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE)); RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));
rb_classext_t *ext = RCLASS_EXT_WRITABLE(obj); rb_classext_t *ext = RCLASS_EXT_WRITABLE(obj);
if (!ext->fields_obj) { if (!ext->fields_obj) {
RB_OBJ_WRITE(obj, &ext->fields_obj, rb_imemo_class_fields_new(obj, 1)); RB_OBJ_WRITE(obj, &ext->fields_obj, rb_imemo_fields_new(obj, 1));
} }
return ext->fields_obj; return ext->fields_obj;
} }
@ -564,7 +564,7 @@ RCLASS_FIELDS_COUNT(VALUE obj)
VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj); VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
if (fields_obj) { if (fields_obj) {
if (rb_shape_obj_too_complex_p(fields_obj)) { if (rb_shape_obj_too_complex_p(fields_obj)) {
return (uint32_t)rb_st_table_size(rb_imemo_class_fields_complex_tbl(fields_obj)); return (uint32_t)rb_st_table_size(rb_imemo_fields_complex_tbl(fields_obj));
} }
else { else {
return RSHAPE_LEN(RBASIC_SHAPE_ID(fields_obj)); return RSHAPE_LEN(RBASIC_SHAPE_ID(fields_obj));

20
internal/imemo.h
View file

@ -42,7 +42,7 @@ enum imemo_type {
imemo_callinfo = 11, imemo_callinfo = 11,
imemo_callcache = 12, imemo_callcache = 12,
imemo_constcache = 13, imemo_constcache = 13,
imemo_class_fields = 14, imemo_fields = 14,
}; };
/* CREF (Class REFerence) is defined in method.h */ /* CREF (Class REFerence) is defined in method.h */
@ -258,7 +258,7 @@ MEMO_V2_SET(struct MEMO *m, VALUE v)
RB_OBJ_WRITE(m, &m->v2, v); RB_OBJ_WRITE(m, &m->v2, v);
} }
struct rb_class_fields { struct rb_fields {
struct RBasic basic; struct RBasic basic;
union { union {
struct { struct {
@ -276,20 +276,20 @@ struct rb_class_fields {
}; };
#define OBJ_FIELD_EXTERNAL IMEMO_FL_USER0 #define OBJ_FIELD_EXTERNAL IMEMO_FL_USER0
#define IMEMO_OBJ_FIELDS(fields) ((struct rb_class_fields *)fields) #define IMEMO_OBJ_FIELDS(fields) ((struct rb_fields *)fields)
VALUE rb_imemo_class_fields_new(VALUE klass, size_t capa); VALUE rb_imemo_fields_new(VALUE klass, size_t capa);
VALUE rb_imemo_class_fields_new_complex(VALUE klass, size_t capa); VALUE rb_imemo_fields_new_complex(VALUE klass, size_t capa);
VALUE rb_imemo_class_fields_clone(VALUE fields_obj); VALUE rb_imemo_fields_clone(VALUE fields_obj);
static inline VALUE * static inline VALUE *
rb_imemo_class_fields_ptr(VALUE obj_fields) rb_imemo_fields_ptr(VALUE obj_fields)
{ {
if (!obj_fields) { if (!obj_fields) {
return NULL; return NULL;
} }
RUBY_ASSERT(IMEMO_TYPE_P(obj_fields, imemo_class_fields)); RUBY_ASSERT(IMEMO_TYPE_P(obj_fields, imemo_fields));
if (RB_UNLIKELY(FL_TEST_RAW(obj_fields, OBJ_FIELD_EXTERNAL))) { if (RB_UNLIKELY(FL_TEST_RAW(obj_fields, OBJ_FIELD_EXTERNAL))) {
return IMEMO_OBJ_FIELDS(obj_fields)->as.external.ptr; return IMEMO_OBJ_FIELDS(obj_fields)->as.external.ptr;
@ -300,13 +300,13 @@ rb_imemo_class_fields_ptr(VALUE obj_fields)
} }
static inline st_table * static inline st_table *
rb_imemo_class_fields_complex_tbl(VALUE obj_fields) rb_imemo_fields_complex_tbl(VALUE obj_fields)
{ {
if (!obj_fields) { if (!obj_fields) {
return NULL; return NULL;
} }
RUBY_ASSERT(IMEMO_TYPE_P(obj_fields, imemo_class_fields)); RUBY_ASSERT(IMEMO_TYPE_P(obj_fields, imemo_fields));
return IMEMO_OBJ_FIELDS(obj_fields)->as.complex.table; return IMEMO_OBJ_FIELDS(obj_fields)->as.complex.table;
} }

2
shape.c
View file

@ -877,7 +877,7 @@ shape_get_next(rb_shape_t *shape, VALUE obj, ID id, bool emit_warnings)
#endif #endif
VALUE klass; VALUE klass;
if (IMEMO_TYPE_P(obj, imemo_class_fields)) { // HACK if (IMEMO_TYPE_P(obj, imemo_fields)) { // HACK
klass = CLASS_OF(obj); klass = CLASS_OF(obj);
} }
else { else {

4
shape.h
View file

@ -111,7 +111,7 @@ static inline shape_id_t
RBASIC_SHAPE_ID(VALUE obj) RBASIC_SHAPE_ID(VALUE obj)
{ {
RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj)); RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));
RUBY_ASSERT(!RB_TYPE_P(obj, T_IMEMO) || IMEMO_TYPE_P(obj, imemo_class_fields)); RUBY_ASSERT(!RB_TYPE_P(obj, T_IMEMO) || IMEMO_TYPE_P(obj, imemo_fields));
#if RBASIC_SHAPE_ID_FIELD #if RBASIC_SHAPE_ID_FIELD
return (shape_id_t)((RBASIC(obj)->shape_id)); return (shape_id_t)((RBASIC(obj)->shape_id));
#else #else
@ -135,7 +135,7 @@ static inline void
RBASIC_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id) RBASIC_SET_SHAPE_ID(VALUE obj, shape_id_t shape_id)
{ {
RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj)); RUBY_ASSERT(!RB_SPECIAL_CONST_P(obj));
RUBY_ASSERT(!RB_TYPE_P(obj, T_IMEMO) || IMEMO_TYPE_P(obj, imemo_class_fields)); RUBY_ASSERT(!RB_TYPE_P(obj, T_IMEMO) || IMEMO_TYPE_P(obj, imemo_fields));
#if RBASIC_SHAPE_ID_FIELD #if RBASIC_SHAPE_ID_FIELD
RBASIC(obj)->shape_id = (VALUE)shape_id; RBASIC(obj)->shape_id = (VALUE)shape_id;
#else #else

48
variable.c
View file

@ -1393,11 +1393,11 @@ rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
case T_IMEMO: case T_IMEMO:
// Handled like T_OBJECT // Handled like T_OBJECT
{ {
RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_class_fields)); RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_fields));
shape_id = RBASIC_SHAPE_ID(obj); shape_id = RBASIC_SHAPE_ID(obj);
if (rb_shape_too_complex_p(shape_id)) { if (rb_shape_too_complex_p(shape_id)) {
st_table *iv_table = rb_imemo_class_fields_complex_tbl(obj); st_table *iv_table = rb_imemo_fields_complex_tbl(obj);
VALUE val; VALUE val;
if (rb_st_lookup(iv_table, (st_data_t)id, (st_data_t *)&val)) { if (rb_st_lookup(iv_table, (st_data_t)id, (st_data_t *)&val)) {
return val; return val;
@ -1408,7 +1408,7 @@ rb_ivar_lookup(VALUE obj, ID id, VALUE undef)
} }
RUBY_ASSERT(!rb_shape_obj_too_complex_p(obj)); RUBY_ASSERT(!rb_shape_obj_too_complex_p(obj));
ivar_list = rb_imemo_class_fields_ptr(obj); ivar_list = rb_imemo_fields_ptr(obj);
break; break;
} }
case T_OBJECT: case T_OBJECT:
@ -1486,7 +1486,7 @@ rb_ivar_delete(VALUE obj, ID id, VALUE undef)
VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj); VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
if (fields_obj) { if (fields_obj) {
if (rb_multi_ractor_p()) { if (rb_multi_ractor_p()) {
fields_obj = rb_imemo_class_fields_clone(fields_obj); fields_obj = rb_imemo_fields_clone(fields_obj);
val = rb_ivar_delete(fields_obj, id, undef); val = rb_ivar_delete(fields_obj, id, undef);
RCLASS_WRITABLE_SET_FIELDS_OBJ(obj, fields_obj); RCLASS_WRITABLE_SET_FIELDS_OBJ(obj, fields_obj);
} }
@ -1523,8 +1523,8 @@ rb_ivar_delete(VALUE obj, ID id, VALUE undef)
rb_bug("Unreachable"); rb_bug("Unreachable");
break; break;
case T_IMEMO: case T_IMEMO:
RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_class_fields)); RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_fields));
fields = rb_imemo_class_fields_ptr(obj); fields = rb_imemo_fields_ptr(obj);
break; break;
case T_OBJECT: case T_OBJECT:
fields = ROBJECT_FIELDS(obj); fields = ROBJECT_FIELDS(obj);
@ -1576,8 +1576,8 @@ too_complex:
break; break;
case T_IMEMO: case T_IMEMO:
RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_class_fields)); RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_fields));
table = rb_imemo_class_fields_complex_tbl(obj); table = rb_imemo_fields_complex_tbl(obj);
break; break;
case T_OBJECT: case T_OBJECT:
@ -2156,8 +2156,8 @@ ivar_defined0(VALUE obj, ID id)
break; break;
case T_IMEMO: case T_IMEMO:
RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_class_fields)); RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_fields));
table = rb_imemo_class_fields_complex_tbl(obj); table = rb_imemo_fields_complex_tbl(obj);
break; break;
case T_OBJECT: case T_OBJECT:
@ -2235,10 +2235,10 @@ iterate_over_shapes_callback(shape_id_t shape_id, void *data)
case T_MODULE: case T_MODULE:
rb_bug("Unreachable"); rb_bug("Unreachable");
case T_IMEMO: case T_IMEMO:
RUBY_ASSERT(IMEMO_TYPE_P(itr_data->obj, imemo_class_fields)); RUBY_ASSERT(IMEMO_TYPE_P(itr_data->obj, imemo_fields));
RUBY_ASSERT(!rb_shape_obj_too_complex_p(itr_data->obj)); RUBY_ASSERT(!rb_shape_obj_too_complex_p(itr_data->obj));
iv_list = rb_imemo_class_fields_ptr(itr_data->obj); iv_list = rb_imemo_fields_ptr(itr_data->obj);
break; break;
default: default:
iv_list = itr_data->fields_tbl->as.shape.fields; iv_list = itr_data->fields_tbl->as.shape.fields;
@ -2313,7 +2313,7 @@ gen_fields_each(VALUE obj, rb_ivar_foreach_callback_func *func, st_data_t arg, b
static void static void
class_fields_each(VALUE fields_obj, rb_ivar_foreach_callback_func *func, st_data_t arg, bool ivar_only) class_fields_each(VALUE fields_obj, rb_ivar_foreach_callback_func *func, st_data_t arg, bool ivar_only)
{ {
IMEMO_TYPE_P(fields_obj, imemo_class_fields); IMEMO_TYPE_P(fields_obj, imemo_fields);
struct iv_itr_data itr_data = { struct iv_itr_data itr_data = {
.obj = fields_obj, .obj = fields_obj,
@ -2324,10 +2324,10 @@ class_fields_each(VALUE fields_obj, rb_ivar_foreach_callback_func *func, st_data
shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj); shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);
if (rb_shape_too_complex_p(shape_id)) { if (rb_shape_too_complex_p(shape_id)) {
rb_st_foreach(rb_imemo_class_fields_complex_tbl(fields_obj), each_hash_iv, (st_data_t)&itr_data); rb_st_foreach(rb_imemo_fields_complex_tbl(fields_obj), each_hash_iv, (st_data_t)&itr_data);
} }
else { else {
itr_data.fields = rb_imemo_class_fields_ptr(fields_obj); itr_data.fields = rb_imemo_fields_ptr(fields_obj);
iterate_over_shapes(shape_id, func, &itr_data); iterate_over_shapes(shape_id, func, &itr_data);
} }
} }
@ -2427,7 +2427,7 @@ rb_field_foreach(VALUE obj, rb_ivar_foreach_callback_func *func, st_data_t arg,
if (SPECIAL_CONST_P(obj)) return; if (SPECIAL_CONST_P(obj)) return;
switch (BUILTIN_TYPE(obj)) { switch (BUILTIN_TYPE(obj)) {
case T_IMEMO: case T_IMEMO:
if (IMEMO_TYPE_P(obj, imemo_class_fields)) { if (IMEMO_TYPE_P(obj, imemo_fields)) {
class_fields_each(obj, func, arg, ivar_only); class_fields_each(obj, func, arg, ivar_only);
} }
break; break;
@ -2476,7 +2476,7 @@ rb_ivar_count(VALUE obj)
return 0; return 0;
} }
if (rb_shape_obj_too_complex_p(fields_obj)) { if (rb_shape_obj_too_complex_p(fields_obj)) {
return rb_st_table_size(rb_imemo_class_fields_complex_tbl(fields_obj)); return rb_st_table_size(rb_imemo_fields_complex_tbl(fields_obj));
} }
return RBASIC_FIELDS_COUNT(fields_obj); return RBASIC_FIELDS_COUNT(fields_obj);
} }
@ -4690,7 +4690,7 @@ class_fields_ivar_set(VALUE klass, VALUE fields_obj, ID id, VALUE val, bool conc
{ {
bool existing = true; bool existing = true;
const VALUE original_fields_obj = fields_obj; const VALUE original_fields_obj = fields_obj;
fields_obj = original_fields_obj ? original_fields_obj : rb_imemo_class_fields_new(klass, 1); fields_obj = original_fields_obj ? original_fields_obj : rb_imemo_fields_new(klass, 1);
shape_id_t current_shape_id = RBASIC_SHAPE_ID(fields_obj); shape_id_t current_shape_id = RBASIC_SHAPE_ID(fields_obj);
shape_id_t next_shape_id = current_shape_id; shape_id_t next_shape_id = current_shape_id;
@ -4711,9 +4711,9 @@ class_fields_ivar_set(VALUE klass, VALUE fields_obj, ID id, VALUE val, bool conc
next_shape_id = rb_shape_transition_add_ivar(fields_obj, id); next_shape_id = rb_shape_transition_add_ivar(fields_obj, id);
if (UNLIKELY(rb_shape_too_complex_p(next_shape_id))) { if (UNLIKELY(rb_shape_too_complex_p(next_shape_id))) {
attr_index_t current_len = RSHAPE_LEN(current_shape_id); attr_index_t current_len = RSHAPE_LEN(current_shape_id);
fields_obj = rb_imemo_class_fields_new_complex(klass, current_len + 1); fields_obj = rb_imemo_fields_new_complex(klass, current_len + 1);
if (current_len) { if (current_len) {
rb_obj_copy_fields_to_hash_table(original_fields_obj, rb_imemo_class_fields_complex_tbl(fields_obj)); rb_obj_copy_fields_to_hash_table(original_fields_obj, rb_imemo_fields_complex_tbl(fields_obj));
RBASIC_SET_SHAPE_ID(fields_obj, next_shape_id); RBASIC_SET_SHAPE_ID(fields_obj, next_shape_id);
} }
goto too_complex; goto too_complex;
@ -4727,9 +4727,9 @@ class_fields_ivar_set(VALUE klass, VALUE fields_obj, ID id, VALUE val, bool conc
// We allocate a new fields_obj even when concurrency isn't a concern // We allocate a new fields_obj even when concurrency isn't a concern
// so that we're embedded as long as possible. // so that we're embedded as long as possible.
fields_obj = rb_imemo_class_fields_new(klass, next_capacity); fields_obj = rb_imemo_fields_new(klass, next_capacity);
if (original_fields_obj) { if (original_fields_obj) {
MEMCPY(rb_imemo_class_fields_ptr(fields_obj), rb_imemo_class_fields_ptr(original_fields_obj), VALUE, RSHAPE_LEN(current_shape_id)); MEMCPY(rb_imemo_fields_ptr(fields_obj), rb_imemo_fields_ptr(original_fields_obj), VALUE, RSHAPE_LEN(current_shape_id));
} }
} }
@ -4737,7 +4737,7 @@ class_fields_ivar_set(VALUE klass, VALUE fields_obj, ID id, VALUE val, bool conc
RUBY_ASSERT(index == (RSHAPE_LEN(next_shape_id) - 1)); RUBY_ASSERT(index == (RSHAPE_LEN(next_shape_id) - 1));
} }
VALUE *fields = rb_imemo_class_fields_ptr(fields_obj); VALUE *fields = rb_imemo_fields_ptr(fields_obj);
RB_OBJ_WRITE(fields_obj, &fields[index], val); RB_OBJ_WRITE(fields_obj, &fields[index], val);
if (!existing) { if (!existing) {
@ -4749,7 +4749,7 @@ class_fields_ivar_set(VALUE klass, VALUE fields_obj, ID id, VALUE val, bool conc
too_complex: too_complex:
{ {
st_table *table = rb_imemo_class_fields_complex_tbl(fields_obj); st_table *table = rb_imemo_fields_complex_tbl(fields_obj);
existing = st_insert(table, (st_data_t)id, (st_data_t)val); existing = st_insert(table, (st_data_t)id, (st_data_t)val);
RB_OBJ_WRITTEN(fields_obj, Qundef, val); RB_OBJ_WRITTEN(fields_obj, Qundef, val);

6
vm_insnhelper.c
View file

@ -1252,8 +1252,8 @@ vm_getivar(VALUE obj, ID id, const rb_iseq_t *iseq, IVC ic, const struct rb_call
if (!fields_obj) { if (!fields_obj) {
return default_value; return default_value;
} }
ivar_list = rb_imemo_class_fields_ptr(fields_obj); ivar_list = rb_imemo_fields_ptr(fields_obj);
shape_id = fields_obj ? RBASIC_SHAPE_ID_FOR_READ(fields_obj) : ROOT_SHAPE_ID; shape_id = RBASIC_SHAPE_ID_FOR_READ(fields_obj);
break; break;
} }
@ -1325,7 +1325,7 @@ vm_getivar(VALUE obj, ID id, const rb_iseq_t *iseq, IVC ic, const struct rb_call
switch (BUILTIN_TYPE(obj)) { switch (BUILTIN_TYPE(obj)) {
case T_CLASS: case T_CLASS:
case T_MODULE: case T_MODULE:
table = rb_imemo_class_fields_complex_tbl(fields_obj); table = rb_imemo_fields_complex_tbl(fields_obj);
break; break;
case T_OBJECT: case T_OBJECT:

2
yjit/src/cruby_bindings.inc.rs generated
View file

@ -410,7 +410,7 @@ pub const imemo_parser_strterm: imemo_type = 10;
pub const imemo_callinfo: imemo_type = 11; pub const imemo_callinfo: imemo_type = 11;
pub const imemo_callcache: imemo_type = 12; pub const imemo_callcache: imemo_type = 12;
pub const imemo_constcache: imemo_type = 13; pub const imemo_constcache: imemo_type = 13;
pub const imemo_class_fields: imemo_type = 14; pub const imemo_fields: imemo_type = 14;
pub type imemo_type = u32; pub type imemo_type = u32;
#[repr(C)] #[repr(C)]
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]

2
zjit/src/cruby_bindings.inc.rs generated
View file

@ -227,7 +227,7 @@ pub const imemo_parser_strterm: imemo_type = 10;
pub const imemo_callinfo: imemo_type = 11; pub const imemo_callinfo: imemo_type = 11;
pub const imemo_callcache: imemo_type = 12; pub const imemo_callcache: imemo_type = 12;
pub const imemo_constcache: imemo_type = 13; pub const imemo_constcache: imemo_type = 13;
pub const imemo_class_fields: imemo_type = 14; pub const imemo_fields: imemo_type = 14;
pub type imemo_type = u32; pub type imemo_type = u32;
pub const METHOD_VISI_UNDEF: rb_method_visibility_t = 0; pub const METHOD_VISI_UNDEF: rb_method_visibility_t = 0;
pub const METHOD_VISI_PUBLIC: rb_method_visibility_t = 1; pub const METHOD_VISI_PUBLIC: rb_method_visibility_t = 1;