entry = ZALLOC(rb_subclass_entry_t);

entry->klass = klass;

anchor = RCLASS_WRITABLE_SUBCLASSES(super);

VM_ASSERT(anchor);

ns_subclasses = (rb_ns_subclasses_t *)anchor->ns_subclasses;

entry->prev = head;

st_insert(tbl, namespace_subclasses_tbl_key(ns), (st_data_t)entry);

}

if (is_module) {

RCLASS_WRITE_NS_MODULE_SUBCLASSES(klass, anchor->ns_subclasses);

{

size_t *size = (size_t *)arg;

size_t count;

count = rb_st_table_size((st_table *)RCLASSEXT_FIELDS(ext));

}

// class IV sizes are allocated as powers of two

*size += SIZEOF_VALUE << bit_length(count);

}

void

rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data)

{

if (rb_gc_impl_during_gc_p(rb_gc_get_objspace())) rb_bug("rb_objspace_reachable_objects_from() is not supported while during GC");

if (!RB_SPECIAL_CONST_P(obj)) {

vm->gc.mark_func_data = prev_mfd;

}

}

}

struct root_objects_data {

#define ENVNMATCH(s1, s2, n) (memcmp((s1), (s2), (n)) == 0)

#endif

static inline rb_encoding *

env_encoding(void)

getenv_with_lock(const char *name)

{

VALUE ret;

const char *val = getenv(name);

ret = env_str_new2(val);

}

return ret;

}

{

const char *val;

val = getenv(name);

}

return val ? true : false;

}

*wvalue = L'\0';

}

/* Use _wputenv_s() instead of SetEnvironmentVariableW() to make sure

* special variables like "TZ" are interpret by libc. */

failed = _wputenv_s(wname, wvalue);

}

ALLOCV_END(buf);

/* even if putenv() failed, clean up and try to delete the

#elif defined(HAVE_SETENV) && defined(HAVE_UNSETENV)

if (value) {

int ret;

ret = setenv(name, value, 1);

}

if (ret) rb_sys_fail_sprintf("setenv(%s)", name);

}

else {

#ifdef VOID_UNSETENV

unsetenv(name);

}

#else

int ret;

ret = unsetenv(name);

}

if (ret) rb_sys_fail_sprintf("unsetenv(%s)", name);

#endif

snprintf(mem_ptr, mem_size, "%s=%s", name, value);

}

for (env_ptr = GET_ENVIRON(environ); (str = *env_ptr) != 0; ++env_ptr) {

if (!strncmp(str, name, len) && str[len] == '=') {

if (!in_origenv(str)) free(str);

}

}

}

if (value) {

int ret;

ret = putenv(mem_ptr);

}

if (ret) {

free(mem_ptr);

size_t len;

int i;

i = envix(name); /* where does it go? */

if (environ == origenviron) { /* need we copy environment? */

finish:;

}

#endif /* WIN32 */

}

rb_encoding *enc = raw ? 0 : rb_locale_encoding();

VALUE ary = rb_ary_new();

char **env = GET_ENVIRON(environ);

while (*env) {

char *s = strchr(*env, '=');

}

FREE_ENVIRON(environ);

}

return ary;

}

char **env;

long cnt = 0;

env = GET_ENVIRON(environ);

for (; *env ; ++env) {

if (strchr(*env, '=')) {

}

FREE_ENVIRON(environ);

}

return LONG2FIX(cnt);

}

{

VALUE ary = rb_ary_new();

char **env = GET_ENVIRON(environ);

while (*env) {

}

FREE_ENVIRON(environ);

}

return ary;

}

VALUE ary = rb_ary_new();

char **env = GET_ENVIRON(environ);

while (*env) {

}

FREE_ENVIRON(environ);

}

if (rb_block_pair_yield_optimizable()) {

for (i=0; i<RARRAY_LEN(ary); i+=2) {

VALUE str = rb_str_buf_new2("{");

rb_encoding *enc = env_encoding();

char **env = GET_ENVIRON(environ);

while (*env) {

const char *s = strchr(*env, '=');

}

FREE_ENVIRON(environ);

}

rb_str_buf_cat2(str, "}");

{

VALUE ary = rb_ary_new();

char **env = GET_ENVIRON(environ);

while (*env) {

char *s = strchr(*env, '=');

}

FREE_ENVIRON(environ);

}

return ary;

}

{

int i = 0;

char **env = GET_ENVIRON(environ);

while (env[i]) i++;

FREE_ENVIRON(environ);

}

return i;

}

{

bool empty = true;

char **env = GET_ENVIRON(environ);

if (env[0] != 0) {

empty = false;

}

FREE_ENVIRON(environ);

}

return RBOOL(empty);

}

VALUE ret = Qfalse;

char **env = GET_ENVIRON(environ);

while (*env) {

char *s = strchr(*env, '=');

}

FREE_ENVIRON(environ);

}

return ret;

}

VALUE result = Qnil;

char **env = GET_ENVIRON(environ);

while (*env) {

}

FREE_ENVIRON(environ);

}

return result;

}

StringValue(value);

VALUE str = Qnil;

char **env = GET_ENVIRON(environ);

while (*env) {

char *s = strchr(*env, '=');

}

FREE_ENVIRON(environ);

}

return str;

}

{

VALUE hash = rb_hash_new();

char **env = GET_ENVIRON(environ);

while (*env) {

char *s = strchr(*env, '=');

}

FREE_ENVIRON(environ);

}

return hash;

}

VALUE result = Qnil;

VALUE key = Qnil;

char **env = GET_ENVIRON(environ);

if (*env) {

const char *p = *env;

}

FREE_ENVIRON(environ);

}

if (!NIL_P(key)) {

env_delete(key);

rb_evict_ivars_to_hash(obj); // fallback to ivptr for ivars from shapes

}

// re-check the classext is not created to avoid the multi-thread race

ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);

if (!ext) {

}

}

}

return ext;

}

// "Too complex" classes could have their IV hash mutated in

// parallel, so lets lock around getting the hash size.

count = (uint32_t)rb_st_table_size(RCLASS_FIELDS_HASH(obj));

}

return count;

}

static void

exported_object_registry_free(void *ptr)

{

}

const rb_data_type_t rb_memory_view_exported_object_registry_data_type = {

static void

register_exported_object(VALUE obj)

{

}

static void

unregister_exported_object(VALUE obj)

{

}

// MemoryView

namespace_generate_id(void)

{

long id;

id = ++namespace_id_counter;

}

return id;

}

rb_thread_acquire_fork_lock();

disable_child_handler_before_fork(&old);

child.pid = pid = rb_fork();

child.error = err = errno;

}

disable_child_handler_fork_parent(&old); /* yes, bad name */

if (

static VALUE

proc_warmup(VALUE _)

{

return Qtrue;

}

ractor_close_outgoing(ec, cr);

// sync with rb_ractor_terminate_interrupt_main_thread()

VM_ASSERT(cr->threads.main != NULL);

cr->threads.main = NULL;

}

}

void

// change ractor status: running -> blocking

rb_vm_t *vm = GET_VM();

rb_vm_ractor_blocking_cnt_inc(vm, cr, file, line);

}

}

}

if (cr->threads.cnt == cr->threads.blocking_cnt) {

rb_vm_t *vm = GET_VM();

rb_vm_ractor_blocking_cnt_dec(vm, cr, __FILE__, __LINE__);

}

}

cr->threads.blocking_cnt--;

.stop = false,

.data = data,

};

rb_objspace_reachable_objects_from(obj, obj_traverse_reachable_i, &d);

}

if (d.stop) return 1;

}

break;

obj_refer_only_shareables_p(VALUE obj)

{

int cnt = 0;

rb_objspace_reachable_objects_from(obj, obj_refer_only_shareables_p_i, &cnt);

}

return cnt == 0;

}

void

rb_ractor_local_storage_delkey(rb_ractor_local_key_t key)

{

if (freed_ractor_local_keys.cnt == freed_ractor_local_keys.capa) {

freed_ractor_local_keys.capa = freed_ractor_local_keys.capa ? freed_ractor_local_keys.capa * 2 : 4;

REALLOC_N(freed_ractor_local_keys.keys, rb_ractor_local_key_t, freed_ractor_local_keys.capa);

}

freed_ractor_local_keys.keys[freed_ractor_local_keys.cnt++] = key;

}

}

static bool

}

}

// The situation may have changed while we waited for the lock.

// So we load the edge again.

edges = RUBY_ATOMIC_PTR_LOAD(shape->edges);

}

}

}

return res;

}

// Rebuilds the table

static void

{

// Check if another thread has already resized

if (RUBY_ATOMIC_VALUE_LOAD(fstring_table_obj) != old_table_obj) {

goto end;

end:

RB_GC_GUARD(old_table_obj);

}

static VALUE

VALUE table_obj;

struct fstring_table_struct *table;

table_obj = RUBY_ATOMIC_VALUE_LOAD(fstring_table_obj);

RUBY_ASSERT(table_obj);

table = RTYPEDDATA_GET_DATA(table_obj);

}

else if (candidate == FSTRING_TABLE_MOVED) {

// Wait

goto retry;

}

rb_define_method(rb_cSymbol, "encoding", sym_encoding, 0);

}

terminate_interrupt = interrupt & TERMINATE_INTERRUPT_MASK; // request from other ractors

if (interrupt & VM_BARRIER_INTERRUPT_MASK) {

}

if (postponed_job_interrupt) {

// TODO MEMO: we can create a new thread in a ractor, but not sure how to do that now.

}

#endif

thread_sched_unlock(sched, lock_owner);

{

}

thread_sched_lock(sched, lock_owner);

}

rb_vm_t *vm = th->vm;

th->sched.finished = false;

ccan_list_add(&vm->ractor.sched.zombie_threads, &th->sched.node.zombie_threads);

}

}

#endif

}

if (NIL_P(name)) {

// Set the temporary classpath to NULL (anonymous):

}

else {

// Ensure the name is a string:

name = rb_str_new_frozen(name);

// Set the temporary classpath to the given name:

}

return mod;

st_data_t data;

int r = 0;

if (st_lookup(generic_fields_tbl(obj, id, false), (st_data_t)obj, &data)) {

*fields_tbl = (struct gen_fields_tbl *)data;

r = 1;

}

}

return r;

}

bool too_complex = rb_shape_obj_too_complex_p(obj);

if (st_delete(generic_fields_tbl_no_ractor_check(obj), &key, &value)) {

struct gen_fields_tbl *fields_tbl = (struct gen_fields_tbl *)value;

xfree(fields_tbl);

}

}

}

size_t

struct gen_fields_tbl *fields_tbl = 0;

shape_id_t shape_id = 0;

st_table* global_iv_table = generic_fields_tbl(obj, 0, false);

if (global_iv_table && st_lookup(global_iv_table, obj, (st_data_t *)&fields_tbl)) {

shape_id = SPECIAL_CONST_SHAPE_ID;

}

}

return shape_id;

}

bool found = false;

VALUE val;

#if !SHAPE_IN_BASIC_FLAGS

shape_id = RCLASS_SHAPE_ID(obj);

#endif

}

}

}

if (found &&

rb_is_instance_id(id) &&

RCLASS_SET_FIELDS_HASH(obj, table);

break;

default:

struct st_table *gen_ivs = generic_fields_tbl_no_ractor_check(obj);

struct gen_fields_tbl *old_fields_tbl = NULL;

fields_tbl->shape_id = shape_id;

#endif

}

}

xfree(old_fields);

struct gen_fields_lookup_ensure_size *fields_lookup = data;

st_update(generic_fields_tbl(obj, fields_lookup->id, false), (st_data_t)obj, generic_fields_lookup_ensure_size, (st_data_t)fields_lookup);

}

FL_SET_RAW(obj, FL_EXIVAR);

#endif

fields_tbl->as.complex.table = st_init_numtable_with_size(1);

st_insert(generic_fields_tbl(obj, fields_lookup->id, false), (st_data_t)obj, (st_data_t)fields_tbl);

}

FL_SET_RAW(obj, FL_EXIVAR);

}

default:

if (shape_id != SPECIAL_CONST_SHAPE_ID) {

struct gen_fields_tbl *fields_tbl = 0;

st_table* global_iv_table = generic_fields_tbl(obj, 0, false);

if (st_lookup(global_iv_table, obj, (st_data_t *)&fields_tbl)) {

rb_bug("Expected shape_id entry in global iv table");

}

}

}

}

#endif

* c.fields_tbl may change in gen_fields_copy due to realloc,

* no need to free

*/

generic_fields_tbl_no_ractor_check(dest);

st_insert(generic_fields_tbl_no_ractor_check(obj), (st_data_t)dest, (st_data_t)new_fields_tbl);

}

rb_shape_set_shape(dest, shape_to_set_on_dest);

}

{

RUBY_ASSERT(FL_TEST(obj, FL_EXIVAR));

st_data_t fields_tbl, obj_data = (st_data_t)obj;

if (st_delete(generic_fields_tbl_, &obj_data, &fields_tbl)) {

FL_UNSET_RAW(obj, FL_EXIVAR);

rb_bug("unreachable");

}

}

}

void

case T_CLASS:

case T_MODULE:

IVAR_ACCESSOR_SHOULD_BE_MAIN_RACTOR(0);

class_fields_each(obj, func, arg, ivar_only);

}

break;

default:

if (FL_TEST(obj, FL_EXIVAR)) {

{

check_before_mod_set(ac->module, ac->name, ac->value, "constant");

const_tbl_update(ac, true);

}

return 0; /* ignored */

}

if (!tbl) return rb_ary_new2(0);

ary = rb_ary_new2(rb_id_table_size(tbl));

rb_id_table_foreach(tbl, rb_local_constants_i, (void *)ary);

}

return ary;

}

tbl = st_init_numtable();

}

if (RCLASS_CONST_TBL(mod)) {

rb_id_table_foreach(RCLASS_CONST_TBL(mod), sv_i, tbl);

}

}

return tbl;

}

{

struct rb_id_table *const_table = RCLASS_CONST_TBL(named_namespace);

RCLASS_WRITE_CLASSPATH(named_namespace, namespace_path, true);

if (const_table) {

rb_id_table_foreach(const_table, set_namespace_path_i, &namespace_path);

}

}

}

static void

check_before_mod_set(klass, id, val, "constant");

struct rb_id_table *tbl = RCLASS_WRITABLE_CONST_TBL(klass);

if (!tbl) {

tbl = rb_id_table_create(0);

const_tbl_update(&ac, false);

}

}

/*

* Resolve and cache class name immediately to resolve ambiguity

rb_class_ensure_writable(obj);

existing = general_ivar_set(obj, id, val, NULL,

class_ivar_set_shape_fields,

class_ivar_set_shape_resize_fields,

class_ivar_set_transition_too_complex,

class_ivar_set_too_complex_table).existing;

}

return existing;

}

if (tbl) {

VALUE val;

bool r;

r = rb_id_table_lookup(tbl, id, &val);

}

if (r) return (rb_const_entry_t *)val;

}

{

return const_lookup(RCLASS_CONST_TBL(klass), id);

}

default:

break;

}

VALUE list = GET_VM()->mark_object_ary;

VALUE head = pin_array_list_append(list, obj);

if (head != list) {

}

RB_GC_GUARD(obj);

}

}

void

VM_ASSERT_TYPE2(klass, T_CLASS, T_ICLASS);

cc = vm_search_cc(klass, ci);

VM_ASSERT(cc);

VM_ASSERT(cc == vm_cc_empty() || !METHOD_ENTRY_INVALIDATED(vm_cc_cme(cc)));

VM_ASSERT(cc == vm_cc_empty() || vm_cc_cme(cc)->called_id == vm_ci_mid(ci));

}

return cc;

}

static void

vm_ic_track_const_chain(rb_control_frame_t *cfp, IC ic, const ID *segments)

{

}

}

// For JIT inlining

const rb_control_frame_t *cfp = ec->cfp;

return cfp->ep[index];

}

VM_ASSERT_TYPE2(klass, T_CLASS, T_ICLASS);

if (rb_objspace_garbage_object_p(klass)) return;

}

}

else {

}

}

}

}

}

}

}

}

static void

new_ci->flag = flag;

new_ci->argc = argc;

st_table *ci_table = vm->ci_table;

VM_ASSERT(ci_table);

st_update(ci_table, (st_data_t)new_ci, ci_lookup_i, (st_data_t)&ci);

} while (ci == NULL);

}

VM_ASSERT(ci);

const rb_callable_method_entry_t *cme;

VM_ASSERT_TYPE2(klass, T_CLASS, T_ICLASS);

cme = cached_callable_method_entry(klass, mid);

if (cme) {

cache_callable_method_entry(klass, mid, cme);

}

}

return cme;

}

REPLICATE_METHOD(rb_eException, idRespond_to_missing);

}

}

void

rb_yjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec, bool jit_exception)

{

}

// GC root for interacting with the GC

// Preprocessed yjit.rb generated during build

#include "yjit.rbinc"

void

rb_zjit_compile_iseq(const rb_iseq_t *iseq, rb_execution_context_t *ec, bool jit_exception)

{

}

extern VALUE *rb_vm_base_ptr(struct rb_control_frame_struct *cfp);

// Preprocessed zjit.rb generated during build

#include "zjit.rbinc"