- VALUE val;

- struct rb_id_table *tbl = ISEQ_COMPILE_DATA(iseq)->ivar_cache_table;

- if (tbl) {

- if (rb_id_table_lookup(tbl,id,&val)) {

- return val;

- }

- }

- else {

- tbl = rb_id_table_create(1);

- ISEQ_COMPILE_DATA(iseq)->ivar_cache_table = tbl;

- }

- val = INT2FIX(ISEQ_BODY(iseq)->ivc_size++);

- rb_id_table_insert(tbl,id,val);

- return val;

- case TS_IVC: /* inline ivar cache */

- * * ivar_get_ic_miss_serial: ivar_get ic miss reason by serial (VM insn)

-RB_DEBUG_COUNTER(ivar_get_ic_miss_serial)

-RB_DEBUG_COUNTER(ivar_get_ic_miss_unset)

-RB_DEBUG_COUNTER(ivar_set_ic_miss_serial)

-RB_DEBUG_COUNTER(ivar_set_ic_miss_unset)

- st_table *index_tbl = RCLASS_IV_INDEX_TBL(klass);

- uint32_t index_tbl_num_entries = index_tbl == NULL ? 0 : (uint32_t)index_tbl->num_entries;

- rb_init_iv_list(obj);

-static int

-free_iv_index_tbl_free_i(st_data_t key, st_data_t value, st_data_t data)

-{

- xfree((void *)value);

- return ST_CONTINUE;

-}

-

-static void

-iv_index_tbl_free(struct st_table *tbl)

-{

- st_foreach(tbl, free_iv_index_tbl_free_i, 0);

- st_free_table(tbl);

-}

-

- if (RCLASS_IV_INDEX_TBL(obj)) {

- iv_index_tbl_free(RCLASS_IV_INDEX_TBL(obj));

- }

- if (RCLASS_IV_INDEX_TBL(obj)) {

- // TODO: more correct value

- size += st_memsize(RCLASS_IV_INDEX_TBL(obj));

- }

-static int

-update_iv_index_tbl_i(st_data_t key, st_data_t value, st_data_t arg)

-{

- rb_objspace_t *objspace = (rb_objspace_t *)arg;

- struct rb_iv_index_tbl_entry *ent = (struct rb_iv_index_tbl_entry *)value;

- UPDATE_IF_MOVED(objspace, ent->class_value);

- return ST_CONTINUE;

-}

-

-

- // ext->iv_index_tbl

- if (ext->iv_index_tbl) {

- st_foreach(ext->iv_index_tbl, update_iv_index_tbl_i, (st_data_t)objspace);

- }

-#define ROBJECT_IV_INDEX_TBL ROBJECT_IV_INDEX_TBL

- struct st_table *iv_index_tbl;

-/**

- * Prevents further modifications to the given object. ::rb_eFrozenError shall

- * be raised if modification is attempted.

- *

- * @param[out] x Object in question.

- */

-static inline void

-rb_obj_freeze_inline(VALUE x)

-{

- if (RB_FL_ABLE(x)) {

- RB_OBJ_FREEZE_RAW(x);

- if (RBASIC_CLASS(x) && !(RBASIC(x)->flags & RUBY_FL_SINGLETON)) {

- rb_freeze_singleton_class(x);

- }

- }

-}

-/* internal/object.h */

-#undef ROBJECT_IV_INDEX_TBL

-

- rb_serial_t class_serial;

- VALUE class_value;

- struct st_table *iv_index_tbl; // ID -> struct rb_iv_index_tbl_entry

-#define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)

-#include "internal/class.h" /* for RCLASS_IV_INDEX_TBL */

-

-#ifdef ROBJECT_IV_INDEX_TBL

-# undef ROBJECT_IV_INDEX_TBL

-#endif

-static inline struct st_table *ROBJECT_IV_INDEX_TBL_inline(VALUE obj);

-

-RBIMPL_ATTR_PURE()

-static inline struct st_table *

-ROBJECT_IV_INDEX_TBL_inline(VALUE obj)

-{

- if (RB_FL_ANY_RAW(obj, ROBJECT_EMBED)) {

- VALUE klass = rb_obj_class(obj);

- return RCLASS_IV_INDEX_TBL(klass);

- }

- else {

- const struct RObject *const ptr = ROBJECT(obj);

- return ptr->as.heap.iv_index_tbl;

- }

-}

-#define ROBJECT_IV_INDEX_TBL ROBJECT_IV_INDEX_TBL_inline

-

- // IVC entries

- for (unsigned int i = 0; i < body->ivc_size; i++, is_entries++) {

- IVC ivc = (IVC)is_entries;

- if (ivc->entry) {

- RUBY_ASSERT(!RB_TYPE_P(ivc->entry->class_value, T_NONE));

-

- VALUE nv = func(data, ivc->entry->class_value);

- if (ivc->entry->class_value != nv) {

- ivc->entry->class_value = nv;

- }

- }

- }

- # Generate merged ivar guards first if needed

- if !status.compile_info.disable_ivar_cache && status.merge_ivar_guards_p

- src << " if (UNLIKELY(!(RB_TYPE_P(GET_SELF(), T_OBJECT) && (rb_serial_t)#{status.ivar_serial} == RCLASS_SERIAL(RBASIC(GET_SELF())->klass) &&"

- if USE_RVARGC

- src << "#{status.max_ivar_index} < ROBJECT_NUMIV(GET_SELF())" # index < ROBJECT_NUMIV(obj)

- else

- if status.max_ivar_index >= ROBJECT_EMBED_LEN_MAX

- src << "#{status.max_ivar_index} < ROBJECT_NUMIV(GET_SELF())" # index < ROBJECT_NUMIV(obj) && !RB_FL_ANY_RAW(obj, ROBJECT_EMBED)

- else

- src << "ROBJECT_EMBED_LEN_MAX == ROBJECT_NUMIV(GET_SELF())" # index < ROBJECT_NUMIV(obj) && RB_FL_ANY_RAW(obj, ROBJECT_EMBED)

- end

- end

- src << "))) {\n"

- src << " goto ivar_cancel;\n"

- src << " }\n"

- end

-

- if !status.compile_info.disable_ivar_cache && ic_copy.entry

- src << " const uint32_t index = #{ic_copy.entry.index};\n"

- if status.merge_ivar_guards_p

- # JIT: Access ivar without checking these VM_ASSERTed prerequisites as we checked them in the beginning of `mjit_compile_body`

- src << " VM_ASSERT(RB_TYPE_P(obj, T_OBJECT));\n"

- src << " VM_ASSERT((rb_serial_t)#{ic_copy.entry.class_serial} == RCLASS_SERIAL(RBASIC(obj)->klass));\n"

- src << " VM_ASSERT(index < ROBJECT_NUMIV(obj));\n"

- if insn_name == :setinstancevariable

- if USE_RVARGC

- src << " if (LIKELY(!RB_OBJ_FROZEN_RAW(obj) && index < ROBJECT_NUMIV(obj))) {\n"

- src << " RB_OBJ_WRITE(obj, &ROBJECT_IVPTR(obj)[index], stack[#{stack_size - 1}]);\n"

- else

- heap_ivar_p = status.max_ivar_index >= ROBJECT_EMBED_LEN_MAX

- src << " if (LIKELY(!RB_OBJ_FROZEN_RAW(obj) && #{heap_ivar_p ? 'true' : 'RB_FL_ANY_RAW(obj, ROBJECT_EMBED)'})) {\n"

- src << " RB_OBJ_WRITE(obj, &ROBJECT(obj)->as.#{heap_ivar_p ? 'heap.ivptr[index]' : 'ary[index]'}, stack[#{stack_size - 1}]);\n"

- end

- src << " }\n"

- else

- src << " VALUE val;\n"

- if USE_RVARGC

- src << " if (LIKELY(index < ROBJECT_NUMIV(obj) && (val = ROBJECT_IVPTR(obj)[index]) != Qundef)) {\n"

- else

- heap_ivar_p = status.max_ivar_index >= ROBJECT_EMBED_LEN_MAX

- src << " if (LIKELY(#{heap_ivar_p ? 'true' : 'RB_FL_ANY_RAW(obj, ROBJECT_EMBED)'} && (val = ROBJECT(obj)->as.#{heap_ivar_p ? 'heap.ivptr[index]' : 'ary[index]'}) != Qundef)) {\n"

- end

- src << " stack[#{stack_size}] = val;\n"

- src << " }\n"

- end

- src << " const rb_serial_t ic_serial = (rb_serial_t)#{ic_copy.entry.class_serial};\n"

- # JIT: cache hit path of vm_getivar/vm_setivar, or cancel JIT (recompile it with exivar)

- if insn_name == :setinstancevariable

- src << " if (LIKELY(RB_TYPE_P(obj, T_OBJECT) && ic_serial == RCLASS_SERIAL(RBASIC(obj)->klass) && index < ROBJECT_NUMIV(obj) && !RB_OBJ_FROZEN_RAW(obj))) {\n"

- src << " VALUE *ptr = ROBJECT_IVPTR(obj);\n"

- src << " RB_OBJ_WRITE(obj, &ptr[index], stack[#{stack_size - 1}]);\n"

- src << " VALUE val;\n"

- src << " if (LIKELY(RB_TYPE_P(obj, T_OBJECT) && ic_serial == RCLASS_SERIAL(RBASIC(obj)->klass) && index < ROBJECT_NUMIV(obj) && (val = ROBJECT_IVPTR(obj)[index]) != Qundef)) {\n"

- src << " stack[#{stack_size}] = val;\n"

- elsif insn_name == :getinstancevariable && !status.compile_info.disable_exivar_cache && ic_copy.entry

- src << " const rb_serial_t ic_serial = (rb_serial_t)#{ic_copy.entry.class_serial};\n"

- src << " const uint32_t index = #{ic_copy.entry.index};\n"

- src << " VALUE val;\n"

- src << " if (LIKELY(FL_TEST_RAW(obj, FL_EXIVAR) && ic_serial == RCLASS_SERIAL(RBASIC(obj)->klass) && rb_ivar_generic_ivtbl_lookup(obj, &ivtbl) && index < ivtbl->numiv && (val = ivtbl->ivptr[index]) != Qundef)) {\n"

- src << " stack[#{stack_size}] = val;\n"

- num_ivars = 0

- status.max_ivar_index = 0

- status.ivar_serial = 0

- ic = body.iseq_encoded[pos+2]

- ic_copy = (status.is_entries + (C.iseq_inline_storage_entry.new(ic) - body.is_entries)).iv_cache

- if ic_copy.entry # Only initialized (ic_serial > 0) IVCs are optimized

- num_ivars += 1

-

- if status.max_ivar_index < ic_copy.entry.index

- status.max_ivar_index = ic_copy.entry.index

- end

-

- if status.ivar_serial == 0

- status.ivar_serial = ic_copy.entry.class_serial

- elsif status.ivar_serial != ic_copy.entry.class_serial

- # Multiple classes have used this ISeq. Give up assuming one serial.

- status.merge_ivar_guards_p = false

- return

- end

- end

- status.merge_ivar_guards_p = status.ivar_serial > 0 && num_ivars >= 2

- if (!ivarg->num_ivar) {

- rb_raise(rb_eRuntimeError, "instance variable added to %"PRIsVALUE" instance",

- CLASS_OF(arg->obj));

- }

- ivar_serial: [self.rb_serial_t, Primitive.cexpr!("OFFSETOF((*((struct compile_status *)NULL)), ivar_serial)")],

- entry: [CType::Pointer.new { self.rb_iv_index_tbl_entry }, Primitive.cexpr!("OFFSETOF((*((struct iseq_inline_iv_cache_entry *)NULL)), entry)")],

- attr_index: CType::Immediate.parse("unsigned int"),

- class_serial: [self.rb_serial_t, Primitive.cexpr!("OFFSETOF((*((struct rb_iv_index_tbl_entry *)NULL)), class_serial)")],

- class_value: [self.VALUE, Primitive.cexpr!("OFFSETOF((*((struct rb_iv_index_tbl_entry *)NULL)), class_value)")],

- rb_serial_t ivar_serial; // ic_serial of IVC in is_entries (used only when merge_ivar_guards_p)

- uint32_t len = dest_len < src_len ? dest_len : src_len;

- MEMCPY(dest_buf, src_buf, VALUE, len);

- VALUE flags = RBASIC(obj)->flags & 0xffffffff; // 4B

- return RBASIC(obj)->flags >> 32;

- initial = @specs.get_flags(obj)

- @specs.get_flags(obj).should == @freeze | initial

- end

-

- it "supports setting the FREEZE flag" do

- obj, _ = @data.call

- initial = @specs.get_flags(obj)

- @specs.set_flags(obj, @freeze | initial).should == @freeze | initial

- obj.should.frozen?

- assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: "aaa", success_count: 3, recompile_count: 1, min_calls: 2)

- assert_eval_with_jit("#{<<~"begin;"}\n#{<<~"end;"}", stdout: "bbb", success_count: 3, min_calls: 3)

- rb_cref_t

- rb_execution_context_t

- union {

- st_table *iv_index_tbl;

- struct gen_ivtbl *ivtbl;

- } u;

- st_data_t index;

- int iv_extended;

-static bool

-iv_index_tbl_lookup(struct st_table *tbl, ID id, uint32_t *indexp)

-{

- st_data_t ent_data;

- int r;

-

- if (tbl == NULL) return false;

-

- RB_VM_LOCK_ENTER();

- {

- r = st_lookup(tbl, (st_data_t)id, &ent_data);

- }

- RB_VM_LOCK_LEAVE();

-

- if (r) {

- struct rb_iv_index_tbl_entry *ent = (void *)ent_data;

- *indexp = ent->index;

- return true;

- }

- else {

- return false;

- }

-}

-

-gen_ivtbl_get(VALUE obj, ID id, struct gen_ivtbl **ivtbl)

- return gen_ivtbl_get(obj, 0, ivtbl);

-}

-

-MJIT_FUNC_EXPORTED VALUE

-rb_ivar_generic_lookup_with_index(VALUE obj, ID id, uint32_t index)

-{

- struct gen_ivtbl *ivtbl;

-

- if (gen_ivtbl_get(obj, id, &ivtbl)) {

- if (LIKELY(index < ivtbl->numiv)) {

- VALUE val = ivtbl->ivptr[index];

- return val;

- }

- }

-

- return Qundef;

-}

-

-static VALUE

-generic_ivar_delete(VALUE obj, ID id, VALUE undef)

-{

- struct gen_ivtbl *ivtbl;

-

- if (gen_ivtbl_get(obj, id, &ivtbl)) {

- st_table *iv_index_tbl = RCLASS_IV_INDEX_TBL(rb_obj_class(obj));

- uint32_t index;

-

- if (iv_index_tbl && iv_index_tbl_lookup(iv_index_tbl, id, &index)) {

- if (index < ivtbl->numiv) {

- VALUE ret = ivtbl->ivptr[index];

-

- ivtbl->ivptr[index] = Qundef;

- return ret == Qundef ? undef : ret;

- }

- }

- }

- return undef;

-}

-

-static VALUE

-generic_ivar_get(VALUE obj, ID id, VALUE undef)

-{

- struct gen_ivtbl *ivtbl;

-

- if (gen_ivtbl_get(obj, id, &ivtbl)) {

- st_table *iv_index_tbl = RCLASS_IV_INDEX_TBL(rb_obj_class(obj));

- uint32_t index;

-

- if (iv_index_tbl && iv_index_tbl_lookup(iv_index_tbl, id, &index)) {

- if (index < ivtbl->numiv) {

- VALUE ret = ivtbl->ivptr[index];

-

- return ret == Qundef ? undef : ret;

- }

- }

- }

- return undef;

-static uint32_t

-iv_index_tbl_newsize(struct ivar_update *ivup)

-{

- if (!ivup->iv_extended) {

- return (uint32_t)ivup->u.iv_index_tbl->num_entries;

- }

- else {

- uint32_t index = (uint32_t)ivup->index; /* should not overflow */

- return (index+1) + (index+1)/4; /* (index+1)*1.25 */

- }

-}

-

- if (ivup->index < ivtbl->numiv) {

- ivup->u.ivtbl = ivtbl;

- uint32_t newsize = iv_index_tbl_newsize(ivup);

- ivtbl = gen_ivtbl_resize(ivtbl, newsize);

- ivup->u.ivtbl = ivtbl;

-static VALUE

-generic_ivar_defined(VALUE obj, ID id)

-{

- struct gen_ivtbl *ivtbl;

- st_table *iv_index_tbl = RCLASS_IV_INDEX_TBL(rb_obj_class(obj));

- uint32_t index;

-

- if (!iv_index_tbl_lookup(iv_index_tbl, id, &index)) return Qfalse;

- if (!gen_ivtbl_get(obj, id, &ivtbl)) return Qfalse;

-

- return RBOOL((index < ivtbl->numiv) && (ivtbl->ivptr[index] != Qundef));

-}

-

-static int

-generic_ivar_remove(VALUE obj, ID id, VALUE *valp)

-{

- struct gen_ivtbl *ivtbl;

- uint32_t index;

- st_table *iv_index_tbl = RCLASS_IV_INDEX_TBL(rb_obj_class(obj));

-

- if (!iv_index_tbl) return 0;

- if (!iv_index_tbl_lookup(iv_index_tbl, id, &index)) return 0;

- if (!gen_ivtbl_get(obj, id, &ivtbl)) return 0;

-

- if (index < ivtbl->numiv) {

- if (ivtbl->ivptr[index] != Qundef) {

- *valp = ivtbl->ivptr[index];

- ivtbl->ivptr[index] = Qundef;

- return 1;

- }

- }

- return 0;

-}

-

- if (gen_ivtbl_get(obj, 0, &ivtbl)) {

- gen_ivtbl_mark(ivtbl);

- if (gen_ivtbl_get(obj, 0, &ivtbl))

- return gen_ivtbl_bytes(ivtbl->numiv);

- case T_OBJECT:

- {

- uint32_t index;

- uint32_t len = ROBJECT_NUMIV(obj);

- VALUE *ptr = ROBJECT_IVPTR(obj);

- VALUE val;

-

- if (iv_index_tbl_lookup(ROBJECT_IV_INDEX_TBL(obj), id, &index) &&

- index < len &&

- (val = ptr[index]) != Qundef) {

- return val;

- }

- else {

- break;

- }

- }

- break;

- if (FL_TEST(obj, FL_EXIVAR))

- return generic_ivar_get(obj, id, undef);

- VALUE *ptr;

- struct st_table *iv_index_tbl;

- uint32_t len, index;

-

- switch (BUILTIN_TYPE(obj)) {

- case T_OBJECT:

- len = ROBJECT_NUMIV(obj);

- ptr = ROBJECT_IVPTR(obj);

- iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);

- if (iv_index_tbl_lookup(iv_index_tbl, id, &index) &&

- index < len) {

- VALUE val = ptr[index];

- ptr[index] = Qundef;

- if (val != Qundef) {

- return val;

- }

- }

- break;

- default:

- if (FL_TEST(obj, FL_EXIVAR))

- return generic_ivar_delete(obj, id, undef);

-static st_table *

-iv_index_tbl_make(VALUE obj, VALUE klass)

-{

- st_table *iv_index_tbl;

-

- if (UNLIKELY(!klass)) {

- rb_raise(rb_eTypeError, "hidden object cannot have instance variables");

- }

-

- if ((iv_index_tbl = RCLASS_IV_INDEX_TBL(klass)) == NULL) {

- RB_VM_LOCK_ENTER();

- if ((iv_index_tbl = RCLASS_IV_INDEX_TBL(klass)) == NULL) {

- iv_index_tbl = RCLASS_IV_INDEX_TBL(klass) = st_init_numtable();

- }

- RB_VM_LOCK_LEAVE();

- }

-

- return iv_index_tbl;

-}

-

-static void

-iv_index_tbl_extend(struct ivar_update *ivup, ID id, VALUE klass)

-{

- ASSERT_vm_locking();

- st_data_t ent_data;

- struct rb_iv_index_tbl_entry *ent;

-

- if (st_lookup(ivup->u.iv_index_tbl, (st_data_t)id, &ent_data)) {

- ent = (void *)ent_data;

- ivup->index = ent->index;

- return;

- }

- if (ivup->u.iv_index_tbl->num_entries >= INT_MAX) {

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

- }

- ent = ALLOC(struct rb_iv_index_tbl_entry);

- ent->index = ivup->index = (uint32_t)ivup->u.iv_index_tbl->num_entries;

- ent->class_value = klass;

- ent->class_serial = RCLASS_SERIAL(klass);

- st_add_direct(ivup->u.iv_index_tbl, (st_data_t)id, (st_data_t)ent);

- ivup->iv_extended = 1;

-}

-

- VALUE klass = rb_obj_class(obj);

- ivup.iv_extended = 0;

- ivup.u.iv_index_tbl = iv_index_tbl_make(obj, klass);

- iv_index_tbl_extend(&ivup, id, klass);

- st_update(generic_ivtbl(obj, id, false), (st_data_t)obj, generic_ivar_update,

- (st_data_t)&ivup);

- ivup.u.ivtbl->ivptr[ivup.index] = val;

-static void

-init_iv_list(VALUE obj, uint32_t len, uint32_t newsize, st_table *index_tbl)

- ROBJECT(obj)->as.heap.iv_index_tbl = index_tbl;

-void

-rb_init_iv_list(VALUE obj)

-{

- st_table *index_tbl = ROBJECT_IV_INDEX_TBL(obj);

- uint32_t newsize = (uint32_t)index_tbl->num_entries;

- uint32_t len = ROBJECT_NUMIV(obj);

- init_iv_list(obj, len, newsize, index_tbl);

-}

-

-// Retrieve or create the id-to-index mapping for a given object and an

-// instance variable name.

-static struct ivar_update

-obj_ensure_iv_index_mapping(VALUE obj, ID id)

- VALUE klass = rb_obj_class(obj);

- struct ivar_update ivup;

- ivup.iv_extended = 0;

- ivup.u.iv_index_tbl = iv_index_tbl_make(obj, klass);

- iv_index_tbl_extend(&ivup, id, klass);

- return ivup;

- // This uint32_t cast shouldn't lose information as it's checked in

- // iv_index_tbl_extend(). The index is stored as an uint32_t in

- // struct rb_iv_index_tbl_entry.

- return (uint32_t)obj_ensure_iv_index_mapping(obj, id).index;

- uint32_t len;

- struct ivar_update ivup = obj_ensure_iv_index_mapping(obj, id);

- len = ROBJECT_NUMIV(obj);

- if (len <= ivup.index) {

- uint32_t newsize = iv_index_tbl_newsize(&ivup);

- init_iv_list(obj, len, newsize, ivup.u.iv_index_tbl);

- RB_OBJ_WRITE(obj, &ROBJECT_IVPTR(obj)[ivup.index], val);

- return val;

- obj_ivar_set(obj, id, val);

- break;

- VALUE val;

- struct st_table *iv_index_tbl;

- uint32_t index;

- case T_OBJECT:

- iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);

- if (iv_index_tbl_lookup(iv_index_tbl, id, &index) &&

- index < ROBJECT_NUMIV(obj) &&

- (val = ROBJECT_IVPTR(obj)[index]) != Qundef) {

- return Qtrue;

- }

- break;

- if (RCLASS_IV_TBL(obj) && lock_st_is_member(RCLASS_IV_TBL(obj), (st_data_t)id))

- break;

- if (FL_TEST(obj, FL_EXIVAR))

- return generic_ivar_defined(obj, id);

- break;

- return Qfalse;

-static ID

-iv_index_tbl_nth_id(st_table *iv_index_tbl, uint32_t index)

-{

- st_data_t key;

- RB_VM_LOCK_ENTER();

- {

- key = rb_st_nth_key(iv_index_tbl, index);

- }

- RB_VM_LOCK_LEAVE();

- return (ID)key;

-}

-

-static inline bool

-ivar_each_i(st_table *iv_index_tbl, VALUE val, uint32_t i, rb_ivar_foreach_callback_func *func, st_data_t arg)

-{

- if (val != Qundef) {

- ID id = iv_index_tbl_nth_id(iv_index_tbl, i);

- switch (func(id, val, arg)) {

- case ST_CHECK:

- case ST_CONTINUE:

- break;

- case ST_STOP:

- return true;

- default:

- rb_bug("unreachable");

- }

- return false;

- st_table *iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);

- if (!iv_index_tbl) return;

- uint32_t i=0;

-

- for (i=0; i < ROBJECT_NUMIV(obj); i++) {

- VALUE val = ROBJECT_IVPTR(obj)[i];

- if (ivar_each_i(iv_index_tbl, val, i, func, arg)) {

- return;

- }

- }

- st_table *iv_index_tbl = RCLASS_IV_INDEX_TBL(rb_obj_class(obj));

- if (!iv_index_tbl) return;

- if (!gen_ivtbl_get(obj, 0, &ivtbl)) return;

- for (uint32_t i=0; i<ivtbl->numiv; i++) {

- VALUE val = ivtbl->ivptr[i];

- if (ivar_each_i(iv_index_tbl, val, i, func, arg)) {

- return;

- }

- }

-}

-

-struct givar_copy {

- VALUE obj;

- VALUE klass;

- st_table *iv_index_tbl;

- struct gen_ivtbl *ivtbl;

-};

-

-static int

-gen_ivar_copy(ID id, VALUE val, st_data_t arg)

-{

- struct givar_copy *c = (struct givar_copy *)arg;

- struct ivar_update ivup;

-

- ivup.iv_extended = 0;

- ivup.u.iv_index_tbl = c->iv_index_tbl;

-

- RB_VM_LOCK_ENTER();

- {

- iv_index_tbl_extend(&ivup, id, c->klass);

- }

- RB_VM_LOCK_LEAVE();

-

- if (ivup.index >= c->ivtbl->numiv) {

- uint32_t newsize = iv_index_tbl_newsize(&ivup);

- c->ivtbl = gen_ivtbl_resize(c->ivtbl, newsize);

- }

- c->ivtbl->ivptr[ivup.index] = val;

-

- RB_OBJ_WRITTEN(c->obj, Qundef, val);

-

- return ST_CONTINUE;

- struct gen_ivtbl *ivtbl;

- if (gen_ivtbl_get(obj, 0, &ivtbl)) {

- struct givar_copy c;

- uint32_t i;

- if (gen_ivtbl_count(ivtbl) == 0)

- if (gen_ivtbl_get(clone, 0, &c.ivtbl)) {

- for (i = 0; i < c.ivtbl->numiv; i++)

- c.ivtbl->ivptr[i] = Qundef;

- }

- else {

- c.ivtbl = gen_ivtbl_resize(0, ivtbl->numiv);

- FL_SET(clone, FL_EXIVAR);

- VALUE klass = rb_obj_class(clone);

- c.iv_index_tbl = iv_index_tbl_make(clone, klass);

- c.obj = clone;

- c.klass = klass;

- gen_ivar_each(obj, gen_ivar_copy, (st_data_t)&c);

- st_insert(generic_ivtbl_no_ractor_check(obj), (st_data_t)clone, (st_data_t)c.ivtbl);

- if (ROBJECT_IV_INDEX_TBL(obj) != 0) {

- st_index_t i, count, num = ROBJECT_NUMIV(obj);

- const VALUE *const ivptr = ROBJECT_IVPTR(obj);

- for (i = count = 0; i < num; ++i) {

- if (ivptr[i] != Qundef) {

- count++;

- }

- }

- return count;

- }

- break;

- if (gen_ivtbl_get(obj, 0, &ivtbl)) {

- return gen_ivtbl_count(ivtbl);

- }

- }

- break;

- st_data_t n, v;

- struct st_table *iv_index_tbl;

- uint32_t index;

- case T_OBJECT:

- iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);

- if (iv_index_tbl_lookup(iv_index_tbl, id, &index) &&

- index < ROBJECT_NUMIV(obj) &&

- (val = ROBJECT_IVPTR(obj)[index]) != Qundef) {

- ROBJECT_IVPTR(obj)[index] = Qundef;

- return val;

- }

- break;

- n = id;

- if (RCLASS_IV_TBL(obj) && lock_st_delete(RCLASS_IV_TBL(obj), &n, &v)) {

- return (VALUE)v;

- default:

- if (FL_TEST(obj, FL_EXIVAR)) {

- if (generic_ivar_remove(obj, id, &val)) {

- return val;

- }

-VALUE rb_ivar_generic_lookup_with_index(VALUE obj, ID id, uint32_t index);

- const unsigned int attr_index;

-#define VM_CALLCACHE_UNMARKABLE IMEMO_FL_USER0

-#define VM_CALLCACHE_ON_STACK IMEMO_FL_USER1

-static inline unsigned int

- return cc->aux_.attr_index - 1;

- return cc->aux_.attr_index > 0;

-static inline uint32_t

-vm_ic_entry_index(const struct iseq_inline_iv_cache_entry *ic)

- return ic->entry->index;

-vm_ic_entry_p(const struct iseq_inline_iv_cache_entry *ic)

- return ic->entry;

-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()

-

-vm_cc_attr_index_set(const struct rb_callcache *cc, int index)

- *(int *)&cc->aux_.attr_index = index + 1;

-vm_ic_entry_set(struct iseq_inline_iv_cache_entry *ic, struct rb_iv_index_tbl_entry *entry, const rb_iseq_t *iseq)

- ic->entry = entry;

- RB_OBJ_WRITTEN(iseq, Qundef, entry->class_value);

-vm_cc_attr_index_initialize(const struct rb_callcache *cc)

- VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));

- VM_ASSERT(cc != vm_cc_empty());

- *(int *)&cc->aux_.attr_index = 0;

- struct rb_iv_index_tbl_entry *entry;

- .cc = &VM_CC_ON_STACK(Qfalse, vm_call_general, { 0 }, cme),

- calling->cc = &VM_CC_ON_STACK(Qfalse, vm_call_general, { 0 }, cme);

-static bool

-iv_index_tbl_lookup(struct st_table *iv_index_tbl, ID id, struct rb_iv_index_tbl_entry **ent)

-{

- int found;

- st_data_t ent_data;

-

- if (iv_index_tbl == NULL) return false;

-

- RB_VM_LOCK_ENTER();

- {

- found = st_lookup(iv_index_tbl, (st_data_t)id, &ent_data);

- }

- RB_VM_LOCK_LEAVE();

- if (found) *ent = (struct rb_iv_index_tbl_entry *)ent_data;

-

- return found ? true : false;

-}

-

-ALWAYS_INLINE(static void fill_ivar_cache(const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, int is_attr, struct rb_iv_index_tbl_entry *ent));

-

-fill_ivar_cache(const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, int is_attr, struct rb_iv_index_tbl_entry *ent)

- // fill cache

- if (!is_attr) {

- vm_ic_entry_set(ic, ent, iseq);

- vm_cc_attr_index_set(cc, ent->index);

- // frozen?

- else if (LIKELY(is_attr ?

- RB_DEBUG_COUNTER_INC_UNLESS(ivar_get_ic_miss_unset, vm_cc_attr_index_p(cc)) :

- RB_DEBUG_COUNTER_INC_UNLESS(ivar_get_ic_miss_serial, vm_ic_entry_p(ic) && ic->entry->class_serial == RCLASS_SERIAL(RBASIC(obj)->klass)))) {

- uint32_t index = !is_attr ? vm_ic_entry_index(ic): (vm_cc_attr_index(cc));

- RB_DEBUG_COUNTER_INC(ivar_get_ic_hit);

-

- if (LIKELY(BUILTIN_TYPE(obj) == T_OBJECT) &&

- LIKELY(index < ROBJECT_NUMIV(obj))) {

- val = ROBJECT_IVPTR(obj)[index];

- }

- else if (FL_TEST_RAW(obj, FL_EXIVAR)) {

- val = rb_ivar_generic_lookup_with_index(obj, id, index);

- }

- goto ret;

- else {

- struct rb_iv_index_tbl_entry *ent;

- if (BUILTIN_TYPE(obj) == T_OBJECT) {

- struct st_table *iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);

- if (iv_index_tbl && iv_index_tbl_lookup(iv_index_tbl, id, &ent)) {

- fill_ivar_cache(iseq, ic, cc, is_attr, ent);

- // get value

- if (ent->index < ROBJECT_NUMIV(obj)) {

- val = ROBJECT_IVPTR(obj)[ent->index];

- VM_ASSERT(rb_ractor_shareable_p(obj) ? rb_ractor_shareable_p(val) : true);

- }

- }

- else if (FL_TEST_RAW(obj, FL_EXIVAR)) {

- struct st_table *iv_index_tbl = RCLASS_IV_INDEX_TBL(rb_obj_class(obj));

- if (iv_index_tbl && iv_index_tbl_lookup(iv_index_tbl, id, &ent)) {

- fill_ivar_cache(iseq, ic, cc, is_attr, ent);

- val = rb_ivar_generic_lookup_with_index(obj, id, ent->index);

- // T_CLASS / T_MODULE

- goto general_path;

- ret:

- if (LIKELY(val != Qundef)) {

- return val;

- return Qnil;

- general_path:

- rb_check_frozen_internal(obj);

-

- if (RB_TYPE_P(obj, T_OBJECT)) {

- struct st_table *iv_index_tbl = ROBJECT_IV_INDEX_TBL(obj);

- struct rb_iv_index_tbl_entry *ent;

- if (iv_index_tbl_lookup(iv_index_tbl, id, &ent)) {

- if (!is_attr) {

- vm_ic_entry_set(ic, ent, iseq);

- }

- else if (ent->index >= INT_MAX) {

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

- }

- else {

- vm_cc_attr_index_set(cc, (int)(ent->index));

- }

- uint32_t index = ent->index;

- if (UNLIKELY(index >= ROBJECT_NUMIV(obj))) {

- rb_init_iv_list(obj);

- VALUE *ptr = ROBJECT_IVPTR(obj);

- RB_OBJ_WRITE(obj, &ptr[index], val);

- RB_DEBUG_COUNTER_INC(ivar_set_ic_miss_iv_hit);

- return val;

- }

-vm_setivar(VALUE obj, ID id, VALUE val, const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, int is_attr)

- if (LIKELY(RB_TYPE_P(obj, T_OBJECT)) &&

- LIKELY(!RB_OBJ_FROZEN_RAW(obj))) {

- VM_ASSERT(!rb_ractor_shareable_p(obj));

- if (LIKELY(

- (!is_attr && RB_DEBUG_COUNTER_INC_UNLESS(ivar_set_ic_miss_serial, vm_ic_entry_p(ic) && ic->entry->class_serial == RCLASS_SERIAL(RBASIC(obj)->klass))) ||

- ( is_attr && RB_DEBUG_COUNTER_INC_UNLESS(ivar_set_ic_miss_unset, vm_cc_attr_index_p(cc))))) {

- uint32_t index = !is_attr ? vm_ic_entry_index(ic) : vm_cc_attr_index(cc);

- if (UNLIKELY(index >= ROBJECT_NUMIV(obj))) {

- rb_init_iv_list(obj);

- VALUE *ptr = ROBJECT_IVPTR(obj);

- RB_OBJ_WRITE(obj, &ptr[index], val);

- RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);

- return val; /* inline cache hit */

- }

- }

- else {

- if (is_attr) {

- return vm_setivar_slowpath_attr(obj, id, val, cc);

- }

- else {

- return vm_setivar_slowpath_ivar(obj, id, val, iseq, ic);

- }

- vm_setivar(obj, id, val, iseq, ic, 0, 0);

-/* Set the instance variable +val+ on object +obj+ at the +index+.

- * This function only works with T_OBJECT objects, so make sure

- * +obj+ is of type T_OBJECT before using this function.

- */

-VALUE

-rb_vm_set_ivar_idx(VALUE obj, uint32_t index, VALUE val)

-{

- RUBY_ASSERT(RB_TYPE_P(obj, T_OBJECT));

-

- rb_check_frozen_internal(obj);

-

- VM_ASSERT(!rb_ractor_shareable_p(obj));

-

- if (UNLIKELY(index >= ROBJECT_NUMIV(obj))) {

- rb_init_iv_list(obj);

- }

- VALUE *ptr = ROBJECT_IVPTR(obj);

- RB_OBJ_WRITE(obj, &ptr[index], val);

-

- return val;

-}

-

- return vm_getivar(calling->recv, vm_cc_cme(cc)->def->body.attr.id, NULL, NULL, cc, TRUE);

-vm_call_attrset(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)

- const struct rb_callcache *cc = calling->cc;

- return vm_setivar(calling->recv, vm_cc_cme(cc)->def->body.attr.id, val, NULL, NULL, cc, 1);

- { 0 },

- calling->cc = &VM_CC_ON_STACK(Qundef, vm_call_general, { 0 },

- calling->cc = &VM_CC_ON_STACK(Qundef, vm_call_general, { 0 }, cme);

- struct rb_callcache *ref_cc = &VM_CC_ON_STACK(Qundef, vm_call_general, { 0 },

- vm_cc_attr_index_initialize(cc);

- VM_CALL_METHOD_ATTR(v,

- vm_call_attrset(ec, cfp, calling),

- CC_SET_FASTPATH(cc, vm_call_attrset, !(vm_ci_flag(ci) & aset_mask)));

- vm_cc_attr_index_initialize(cc);

- panic!("immediate value too large");

- let ivar_index: u32 = unsafe { rb_obj_ensure_iv_index_mapping(recv, ivar_name) };

-

- // Call rb_vm_set_ivar_idx with the receiver, the index of the ivar, and the value

- rb_vm_set_ivar_idx as *const u8,

- Opnd::Imm(ivar_index.into()),

- // FIXME: Mapping the index could fail when there is too many ivar names. If we're

- // compiling for a branch stub that can cause the exception to be thrown from the

- // wrong PC.

- let ivar_index =

- unsafe { rb_obj_ensure_iv_index_mapping(comptime_receiver, ivar_name) }.as_usize();

- if USE_RVARGC != 0 {

- // Check that the ivar table is big enough

- // Check that the slot is inside the ivar table (num_slots > index)

- let num_slots = Opnd::mem(32, recv, ROBJECT_OFFSET_NUMIV);

- asm.cmp(num_slots, Opnd::UImm(ivar_index as u64));

- asm.jbe(counted_exit!(ocb, side_exit, getivar_idx_out_of_range).into());

- let test_result = unsafe { FL_TEST_RAW(comptime_receiver, VALUE(ROBJECT_EMBED.as_usize())) != VALUE(0) };

- if test_result {

- // See ROBJECT_IVPTR() from include/ruby/internal/core/robject.h

- // Guard that self is embedded

- // TODO: BT and JC is shorter

- asm.comment("guard embedded getivar");

- let flags_opnd = Opnd::mem(64, recv, RUBY_OFFSET_RBASIC_FLAGS);

- asm.test(flags_opnd, Opnd::UImm(ROBJECT_EMBED as u64));

- let side_exit = counted_exit!(ocb, side_exit, getivar_megamorphic);

- jit_chain_guard(

- JCC_JZ,

- jit,

- &starting_context,

- asm,

- ocb,

- max_chain_depth,

- side_exit,

- );

- let offs = ROBJECT_OFFSET_AS_ARY + (ivar_index * SIZEOF_VALUE) as i32;

- // Guard that the variable is not Qundef

- asm.cmp(ivar_opnd, Qundef.into());

- let out_val = asm.csel_e(Qnil.into(), ivar_opnd);

-

- asm.mov(out_opnd, out_val);

- // Guard that value is *not* embedded

- // See ROBJECT_IVPTR() from include/ruby/internal/core/robject.h

- asm.comment("guard extended getivar");

- let flags_opnd = Opnd::mem(64, recv, RUBY_OFFSET_RBASIC_FLAGS);

- asm.test(flags_opnd, Opnd::UImm(ROBJECT_EMBED as u64));

- let megamorphic_side_exit = counted_exit!(ocb, side_exit, getivar_megamorphic);

- jit_chain_guard(

- JCC_JNZ,

- jit,

- &starting_context,

- asm,

- ocb,

- max_chain_depth,

- megamorphic_side_exit,

- );

-

- asm.cmp(num_slots, Opnd::UImm(ivar_index as u64));

- let ivar_opnd = Opnd::mem(64, tbl_opnd, (SIZEOF_VALUE * ivar_index) as i32);

-

- // Check that the ivar is not Qundef

- asm.cmp(ivar_opnd, Qundef.into());

- let out_val = asm.csel_ne(ivar_opnd, Qnil.into());

- // Push the ivar on the stack

- asm.mov(out_opnd, out_val);

- let comptime_val_klass = comptime_val.class_of();

- jit_guard_known_klass(

- jit,

- ctx,

- asm,

- ocb,

- comptime_val_klass,

- self_asm_opnd,

- SelfOpnd,

- comptime_val,

- GET_IVAR_MAX_DEPTH,

- side_exit,

- );

- pub fn rb_vm_set_ivar_idx(obj: VALUE, idx: u32, val: VALUE) -> VALUE;

- (flags_bits & (RUBY_T_MASK as usize)) as ruby_value_type

-#[derive(Debug, Copy, Clone)]

- pub entry: *mut rb_iv_index_tbl_entry,

-pub struct rb_iv_index_tbl_entry {

- pub index: u32,

- pub class_serial: rb_serial_t,

- pub class_value: VALUE,

-}

-#[repr(C)]