rb_gc_rebuild_shape(VALUE obj, size_t heap_id)

{

shape_id_t orig_shape_id = rb_obj_shape_id(obj);

return (uint32_t)orig_shape_id;

}

shape_id_t src_shape_id = RBASIC_SHAPE_ID(obj);

rb_shape_copy_complex_ivars(dest, obj, src_shape_id, ROBJECT_FIELDS_HASH(obj));

return;

}

RUBY_ASSERT(RSHAPE(initial_shape_id)->type == SHAPE_T_OBJECT);

dest_shape_id = rb_shape_rebuild(initial_shape_id, src_shape_id);

st_table *table = rb_st_init_numtable_with_size(src_num_ivs);

rb_obj_copy_ivs_to_hash_table(obj, table);

rb_obj_init_too_complex(dest, table);

if (RB_OBJ_FROZEN(obj)) {

shape_id_t next_shape_id = rb_shape_transition_frozen(clone);

rb_evict_ivars_to_hash(clone);

}

else {

shape_id_t next_shape_id = rb_shape_transition_frozen(clone);

// If we're out of shapes, but we want to freeze, then we need to

// evacuate this clone to a hash

rb_evict_ivars_to_hash(clone);

}

else {

return (shape_id_t)(shape - GET_SHAPE_TREE()->shape_list);

}

void

rb_shape_each_shape_id(each_shape_callback callback, void *data)

{

rb_shape_t *res = NULL;

// There should never be outgoing edges from "too complex", except for SHAPE_FROZEN and SHAPE_OBJ_ID

*variation_created = false;

// We found a new parent. Create a child of the new parent that

// has the same attributes as this shape.

if (new_parent) {

return new_parent;

}

bool dont_care;

rb_shape_t *new_child = get_next_shape_internal(new_parent, shape->edge_name, shape->type, &dont_care, true);

return new_child;

}

shape_id_t shape_id = rb_obj_shape_id(obj);

rb_shape_t *shape = RSHAPE(shape_id);

rb_shape_t *removed_shape = NULL;

rb_shape_t *new_shape = remove_shape_recursive(shape, id, &removed_shape);

shape_get_next(rb_shape_t *shape, VALUE obj, ID id, bool emit_warnings)

{

RUBY_ASSERT(!is_instance_id(id) || RTEST(rb_sym2str(ID2SYM(id))));

return shape;

}

// It doesn't make sense to ask for the index of an IV that's stored

// on an object that is "too complex" as it uses a hash for storing IVs

if (!shape_cache_get_iv_index(shape, id, value)) {

// If it wasn't in the ancestor cache, then don't do a linear search

RUBY_FUNC_EXPORTED bool

rb_shape_obj_too_complex_p(VALUE obj)

{

}

bool

{

}

size_t

{

shape_id_t shape_id = NUM2INT(rb_struct_getmember(self, rb_intern("id")));

rb_shape_t *shape = RSHAPE(shape_id);

}

static VALUE

bool rb_shape_get_iv_index(shape_id_t shape_id, ID id, attr_index_t *value);

bool rb_shape_get_iv_index_with_hint(shape_id_t shape_id, ID id, attr_index_t *value, shape_id_t *shape_id_hint);

RUBY_FUNC_EXPORTED bool rb_shape_obj_too_complex_p(VALUE obj);

bool rb_shape_has_object_id(shape_id_t shape_id);

shape_id_t rb_shape_transition_frozen(VALUE obj);

RUBY_ASSERT(!SPECIAL_CONST_P(obj));

RUBY_ASSERT(RSHAPE(target_shape_id)->type == SHAPE_IVAR || RSHAPE(target_shape_id)->type == SHAPE_OBJ_ID);

st_table *fields_hash;

switch (BUILTIN_TYPE(obj)) {

case T_CLASS:

VALUE val;

RB_VM_LOCKING() {

st_table * iv_table = RCLASS_FIELDS_HASH(obj);

if (rb_st_lookup(iv_table, (st_data_t)id, (st_data_t *)&val)) {

found = true;

}

case T_OBJECT:

{

st_table * iv_table = ROBJECT_FIELDS_HASH(obj);

VALUE val;

if (rb_st_lookup(iv_table, (st_data_t)id, (st_data_t *)&val)) {

}

shape_id_t old_shape_id = rb_obj_shape_id(obj);

goto too_complex;

}

return undef;

}

rb_evict_fields_to_hash(obj);

goto too_complex;

}

shape_id_t current_shape_id = RBASIC_SHAPE_ID(obj);

goto too_complex;

}

attr_index_t index;

if (!rb_shape_get_iv_index(current_shape_id, id, &index)) {

result.existing = false;

if (index >= SHAPE_MAX_FIELDS) {

rb_raise(rb_eArgError, "too many instance variables");

}

shape_id_t next_shape_id = rb_shape_transition_add_ivar(obj, id);

transition_too_complex_func(obj, data);

goto too_complex;

}

}

set_shape_id_func(obj, next_shape_id, data);

}

{

shape_id_t current_shape_id = RBASIC_SHAPE_ID(obj);

transition_too_complex_func(obj, data);

}

// If we're transitioning from "not complex" to "too complex"

// then evict ivars. This can happen if we run out of shapes

rb_evict_fields_to_hash(x);

}

rb_shape_set_shape_id(x, next_shape_id);

};

shape_id_t shape_id = RBASIC_SHAPE_ID(obj);

rb_st_foreach(ROBJECT_FIELDS_HASH(obj), each_hash_iv, (st_data_t)&itr_data);

}

else {

};

shape_id_t shape_id = RBASIC_SHAPE_ID(obj);

rb_st_foreach(fields_tbl->as.complex.table, each_hash_iv, (st_data_t)&itr_data);

}

else {

};

shape_id_t shape_id = RBASIC_SHAPE_ID(obj);

rb_st_foreach(RCLASS_WRITABLE_FIELDS_HASH(obj), each_hash_iv, (st_data_t)&itr_data);

}

else {

FL_SET(dest, FL_EXIVAR);

rb_shape_copy_complex_ivars(dest, obj, src_shape_id, obj_fields_tbl->as.complex.table);

return;

}

RUBY_ASSERT(RSHAPE(initial_shape_id)->type == SHAPE_ROOT);

dest_shape_id = rb_shape_rebuild(initial_shape_id, src_shape_id);

st_table *table = rb_st_init_numtable_with_size(src_num_ivs);

rb_obj_copy_ivs_to_hash_table(obj, table);

rb_obj_init_too_complex(dest, table);

}

if (LIKELY(cached_id == shape_id)) {

if (index == ATTR_INDEX_NOT_SET) {

return default_value;

}

#endif

st_table *table = NULL;

switch (BUILTIN_TYPE(obj)) {

case T_CLASS:

static void

populate_cache(attr_index_t index, shape_id_t next_shape_id, ID id, const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, bool is_attr)

{

// Cache population code

if (is_attr) {

shape_id_t next_shape_id = RBASIC_SHAPE_ID(obj);

populate_cache(index, next_shape_id, id, iseq, ic, cc, is_attr);

}

VM_ASSERT(!rb_ractor_shareable_p(obj) || rb_obj_frozen_p(obj));

shape_id_t shape_id = RBASIC_SHAPE_ID(obj);

if (LIKELY(shape_id == dest_shape_id)) {

RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);

let new_shape = if !shape_too_complex && receiver_t_object && ivar_index.is_none() {

let current_shape = comptime_receiver.shape_of();

let next_shape_id = unsafe { rb_shape_transition_add_ivar_no_warnings(comptime_receiver, ivar_name) };

// If the VM ran out of shapes, or this class generated too many leaf,

// it may be de-optimized into OBJ_TOO_COMPLEX_SHAPE (hash-table).

if new_shape_too_complex {

Some((next_shape_id, None, 0_usize))

} else {

let current_capacity = unsafe { (*current_shape).capacity };

// If the new shape has a different capacity, or is TOO_COMPLEX, we'll have to

pub fn rb_obj_shape_id(obj: VALUE) -> shape_id_t;

pub fn rb_shape_get_iv_index(shape_id: shape_id_t, id: ID, value: *mut attr_index_t) -> bool;

pub fn rb_shape_obj_too_complex_p(obj: VALUE) -> bool;

pub fn rb_shape_transition_add_ivar_no_warnings(obj: VALUE, id: ID) -> shape_id_t;

pub fn rb_gvar_get(arg1: ID) -> VALUE;

pub fn rb_gvar_set(arg1: ID, arg2: VALUE) -> VALUE;