11#define vm_exec rb_vm_exec
13#include "eval_intern.h"
16#include "internal/compile.h"
17#include "internal/cont.h"
18#include "internal/error.h"
19#include "internal/eval.h"
20#include "internal/inits.h"
21#include "internal/object.h"
22#include "internal/parse.h"
23#include "internal/proc.h"
24#include "internal/re.h"
25#include "internal/symbol.h"
26#include "internal/thread.h"
27#include "internal/vm.h"
28#include "internal/sanitizers.h"
29#include "internal/variable.h"
36#include "vm_callinfo.h"
39#include "vm_insnhelper.h"
40#include "ractor_core.h"
50#include "probes_helper.h"
52#ifdef RUBY_ASSERT_CRITICAL_SECTION
53int ruby_assert_critical_section_entered = 0;
56VALUE rb_str_concat_literals(
size_t,
const VALUE*);
69extern const char *
const rb_debug_counter_names[];
71PUREFUNC(
static inline const VALUE *VM_EP_LEP(
const VALUE *));
72static inline const VALUE *
73VM_EP_LEP(
const VALUE *ep)
75 while (!VM_ENV_LOCAL_P(ep)) {
76 ep = VM_ENV_PREV_EP(ep);
94 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
102rb_vm_ep_local_ep(
const VALUE *ep)
104 return VM_EP_LEP(ep);
108static inline const VALUE *
111 return VM_EP_LEP(cfp->ep);
114static inline const VALUE *
117 return VM_ENV_PREV_EP(cfp->ep);
124 const VALUE *ep = VM_CF_LEP(cfp);
125 return VM_ENV_BLOCK_HANDLER(ep);
131 return VM_FRAME_CFRAME_KW_P(cfp);
137 return VM_CF_BLOCK_HANDLER(cfp);
144 const VALUE *start = ec->vm_stack;
145 const VALUE *end = (
VALUE *)ec->vm_stack + ec->vm_stack_size;
146 VM_ASSERT(start != NULL);
148 if (start <= (
VALUE *)cfp && (
VALUE *)cfp < end) {
159 const VALUE *start = ec->vm_stack;
161 VM_ASSERT(start != NULL);
163 if (start <= ep && ep < end) {
174 if (VM_EP_IN_HEAP_P(ec, ep)) {
175 VALUE envval = ep[VM_ENV_DATA_INDEX_ENV];
177 if (!UNDEF_P(envval)) {
180 VM_ASSERT(vm_assert_env(envval));
181 VM_ASSERT(VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED));
182 VM_ASSERT(env->ep == ep);
192rb_vm_ep_in_heap_p(
const VALUE *ep)
195 if (ec->vm_stack == NULL)
return TRUE;
196 return vm_ep_in_heap_p_(ec, ep);
203 VM_ASSERT(!VM_CFP_IN_HEAP_P(GET_EC(), cfp));
211 VM_ASSERT(!VM_CFP_IN_HEAP_P(GET_EC(), cfp));
220 return VM_TAGGED_PTR_REF(block_handler, 0x03) == captured;
226 VALUE block_handler = ec->passed_block_handler;
227 ec->passed_block_handler = VM_BLOCK_HANDLER_NONE;
228 vm_block_handler_verify(block_handler);
229 return block_handler;
233vm_cref_new0(
VALUE klass, rb_method_visibility_t visi,
int module_func,
rb_cref_t *prev_cref,
int pushed_by_eval,
int use_prev_prev,
int singleton)
236 int omod_shared = FALSE;
245 scope_visi.visi.method_visi = visi;
246 scope_visi.visi.module_func = module_func;
249 if (prev_cref != NULL && prev_cref != (
void *)1 ) {
250 refinements = CREF_REFINEMENTS(prev_cref);
252 if (!
NIL_P(refinements)) {
254 CREF_OMOD_SHARED_SET(prev_cref);
258 VM_ASSERT(singleton || klass);
260 cref = (
rb_cref_t *)rb_imemo_new(imemo_cref, klass, (
VALUE)(use_prev_prev ? CREF_NEXT(prev_cref) : prev_cref), scope_visi.value, refinements);
262 if (pushed_by_eval) CREF_PUSHED_BY_EVAL_SET(cref);
263 if (omod_shared) CREF_OMOD_SHARED_SET(cref);
264 if (singleton) CREF_SINGLETON_SET(cref);
270vm_cref_new(
VALUE klass, rb_method_visibility_t visi,
int module_func,
rb_cref_t *prev_cref,
int pushed_by_eval,
int singleton)
272 return vm_cref_new0(klass, visi, module_func, prev_cref, pushed_by_eval, FALSE, singleton);
276vm_cref_new_use_prev(
VALUE klass, rb_method_visibility_t visi,
int module_func,
rb_cref_t *prev_cref,
int pushed_by_eval)
278 return vm_cref_new0(klass, visi, module_func, prev_cref, pushed_by_eval, TRUE, FALSE);
284 return SYMBOL_P(key) ? ST_DELETE : ST_CONTINUE;
291 rb_cref_t *next_cref = CREF_NEXT(cref), *new_cref;
292 int pushed_by_eval = CREF_PUSHED_BY_EVAL(cref);
293 int singleton = CREF_SINGLETON(cref);
295 new_cref = vm_cref_new(cref->klass_or_self, visi->method_visi, visi->module_func, next_cref, pushed_by_eval, singleton);
297 if (!
NIL_P(CREF_REFINEMENTS(cref))) {
298 VALUE ref = rb_hash_dup(CREF_REFINEMENTS(cref));
299 rb_hash_foreach(ref, ref_delete_symkey,
Qnil);
300 CREF_REFINEMENTS_SET(new_cref, ref);
301 CREF_OMOD_SHARED_UNSET(new_cref);
309rb_vm_cref_dup_without_refinements(
const rb_cref_t *cref)
312 rb_cref_t *next_cref = CREF_NEXT(cref), *new_cref;
313 int pushed_by_eval = CREF_PUSHED_BY_EVAL(cref);
314 int singleton = CREF_SINGLETON(cref);
316 new_cref = vm_cref_new(cref->klass_or_self, visi->method_visi, visi->module_func, next_cref, pushed_by_eval, singleton);
318 if (!
NIL_P(CREF_REFINEMENTS(cref))) {
319 CREF_REFINEMENTS_SET(new_cref,
Qnil);
320 CREF_OMOD_SHARED_UNSET(new_cref);
329 rb_cref_t *cref = vm_cref_new(rb_cObject, METHOD_VISI_PRIVATE , FALSE, NULL, FALSE, FALSE);
330 VALUE top_wrapper = rb_ec_thread_ptr(ec)->top_wrapper;
333 cref = vm_cref_new(top_wrapper, METHOD_VISI_PRIVATE, FALSE, cref, FALSE, FALSE);
340rb_vm_cref_new_toplevel(
void)
342 return vm_cref_new_toplevel(GET_EC());
346vm_cref_dump(
const char *mesg,
const rb_cref_t *cref)
348 ruby_debug_printf(
"vm_cref_dump: %s (%p)\n", mesg, (
void *)cref);
351 ruby_debug_printf(
"= cref| klass: %s\n", RSTRING_PTR(
rb_class_path(CREF_CLASS(cref))));
352 cref = CREF_NEXT(cref);
359 *((
const VALUE **)&dst->as.captured.ep) = ep;
367 RB_OBJ_WRITE(bindval, &bind->block.as.captured.code.iseq, env->iseq);
368 rb_vm_block_ep_update(bindval, &bind->block, env->ep);
371#if VM_COLLECT_USAGE_DETAILS
372static void vm_collect_usage_operand(
int insn,
int n,
VALUE op);
373static void vm_collect_usage_insn(
int insn);
374static void vm_collect_usage_register(
int reg,
int isset);
379 int argc,
const VALUE *argv,
int kw_splat,
VALUE block_handler,
383#if USE_MJIT || USE_YJIT
392 uintptr_t mjit_state = (uintptr_t)(body->jit_func);
393 ASSUME(MJIT_FUNC_STATE_P(mjit_state));
394 switch ((
enum rb_mjit_func_state)mjit_state) {
395 case MJIT_FUNC_NOT_COMPILED:
396 if (body->total_calls == mjit_opts.call_threshold) {
397 rb_mjit_add_iseq_to_process(iseq);
398 if (UNLIKELY(mjit_opts.wait && !MJIT_FUNC_STATE_P(body->jit_func))) {
399 return body->jit_func(ec, ec->cfp);
403 case MJIT_FUNC_COMPILING:
404 case MJIT_FUNC_FAILED:
419 bool yjit_enabled = rb_yjit_enabled_p();
420 if (yjit_enabled || mjit_call_p) {
430 if (body->total_calls == rb_yjit_call_threshold()) {
433 if (!rb_yjit_compile_iseq(iseq, ec)) {
439 if ((func = body->jit_func) == 0) {
443 else if (UNLIKELY(MJIT_FUNC_STATE_P(func = body->jit_func))) {
444 return mjit_check_iseq(ec, iseq, body);
448 return func(ec, ec->cfp);
452#include "vm_insnhelper.c"
458#include "vm_method.c"
467VALUE rb_mRubyVMFrozenCore;
468VALUE rb_block_param_proxy;
470VALUE ruby_vm_const_missing_count = 0;
471rb_vm_t *ruby_current_vm_ptr = NULL;
473bool ruby_vm_keep_script_lines;
475#ifdef RB_THREAD_LOCAL_SPECIFIER
482 return ruby_current_ec;
487 ruby_current_ec = ec;
492native_tls_key_t ruby_current_ec_key;
497unsigned int ruby_vm_event_local_num;
499rb_serial_t ruby_vm_constant_cache_invalidations = 0;
500rb_serial_t ruby_vm_constant_cache_misses = 0;
501rb_serial_t ruby_vm_global_cvar_state = 1;
504 .flags =
T_IMEMO | (imemo_callcache <<
FL_USHIFT) | VM_CALLCACHE_UNMARKABLE,
507 .call_ = vm_call_general,
513static const struct rb_callcache vm_empty_cc_for_super = {
514 .flags =
T_IMEMO | (imemo_callcache <<
FL_USHIFT) | VM_CALLCACHE_UNMARKABLE,
517 .call_ = vm_call_super_method,
523static void thread_free(
void *ptr);
526rb_vm_inc_const_missing_count(
void)
528 ruby_vm_const_missing_count +=1;
531MJIT_FUNC_EXPORTED
int
537 if (!ec) ec = GET_EC();
538 if (!rb_ec_frame_method_id_and_class(ec, &
id, 0, &klass) || !klass)
542 klass =
RBASIC(klass)->klass;
546 if (
NIL_P(klass))
return FALSE;
551 const char *classname, *filename;
553 if (methodname && (filename = rb_source_location_cstr(&args->line_no)) != 0) {
555 classname =
"<unknown>";
556 args->classname = classname;
557 args->methodname = methodname;
558 args->filename = filename;
593 static VALUE sym_constant_cache_invalidations, sym_constant_cache_misses, sym_global_cvar_state, sym_next_shape_id;
597 if (rb_check_arity(argc, 0, 1) == 1) {
601 else if (RB_TYPE_P(arg,
T_HASH))
607 hash = rb_hash_new();
610#define S(s) sym_##s = ID2SYM(rb_intern_const(#s))
611 S(constant_cache_invalidations);
612 S(constant_cache_misses);
613 S(global_cvar_state);
617#define SET(name, attr) \
618 if (key == sym_##name) \
619 return SERIALT2NUM(attr); \
620 else if (hash != Qnil) \
621 rb_hash_aset(hash, sym_##name, SERIALT2NUM(attr));
623 SET(constant_cache_invalidations, ruby_vm_constant_cache_invalidations);
624 SET(constant_cache_misses, ruby_vm_constant_cache_misses);
625 SET(global_cvar_state, ruby_vm_global_cvar_state);
626 SET(next_shape_id, (rb_serial_t)GET_VM()->next_shape_id);
630 ruby_debug_counter_show_at_exit(FALSE);
631 for (
size_t i = 0; i < RB_DEBUG_COUNTER_MAX; i++) {
632 const VALUE name = rb_sym_intern_ascii_cstr(rb_debug_counter_names[i]);
638 else if (hash !=
Qnil) {
639 rb_hash_aset(hash, name, boxed_value);
656 if (ISEQ_BODY(iseq)->
type != ISEQ_TYPE_TOP) {
661 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_TOP | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH, rb_ec_thread_ptr(ec)->top_self,
662 VM_BLOCK_HANDLER_NONE,
663 (
VALUE)vm_cref_new_toplevel(ec),
664 ISEQ_BODY(iseq)->iseq_encoded, ec->cfp->sp,
665 ISEQ_BODY(iseq)->local_table_size, ISEQ_BODY(iseq)->stack_max);
671 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_EVAL | VM_FRAME_FLAG_FINISH,
672 vm_block_self(base_block), VM_GUARDED_PREV_EP(vm_block_ep(base_block)),
674 ISEQ_BODY(iseq)->iseq_encoded,
675 ec->cfp->sp, ISEQ_BODY(iseq)->local_table_size,
676 ISEQ_BODY(iseq)->stack_max);
685 GetBindingPtr(toplevel_binding, bind);
688 vm_set_eval_stack(ec, iseq, 0, &bind->block);
691 if (ISEQ_BODY(iseq)->local_table_size > 0) {
692 vm_bind_update_env(toplevel_binding, bind, vm_make_env_object(ec, ec->cfp));
699 while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
703 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
711 while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
712 if (VM_FRAME_RUBYFRAME_P(cfp)) {
715 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
725 if (VM_FRAME_RUBYFRAME_P(cfp)) {
729 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
731 while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
732 if (VM_FRAME_RUBYFRAME_P(cfp)) {
736 if (VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_PASSED) == FALSE) {
739 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
745rb_vm_pop_cfunc_frame(
void)
752 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
753 vm_pop_frame(ec, cfp, cfp->ep);
762 while (ec->cfp != cfp) {
764 printf(
"skipped frame: %s\n", vm_frametype_name(ec->cfp));
766 if (VM_FRAME_TYPE(ec->cfp) != VM_FRAME_MAGIC_CFUNC) {
770 rb_vm_pop_cfunc_frame();
783 nl->next = vm->at_exit;
788ruby_vm_run_at_exit_hooks(
rb_vm_t *vm)
794 rb_vm_at_exit_func *func = l->func;
808 fputs(
"---\n", stderr);
809 ruby_debug_printf(
"envptr: %p\n", (
void *)&env->ep[0]);
810 ruby_debug_printf(
"envval: %10p ", (
void *)env->ep[1]);
812 ruby_debug_printf(
"ep: %10p\n", (
void *)env->ep);
813 if (rb_vm_env_prev_env(env)) {
814 fputs(
">>\n", stderr);
815 check_env_value(rb_vm_env_prev_env(env));
816 fputs(
"<<\n", stderr);
824 if (check_env(env)) {
834 switch (vm_block_handler_type(block_handler)) {
835 case block_handler_type_ifunc:
836 case block_handler_type_iseq:
837 return rb_vm_make_proc(ec, VM_BH_TO_CAPT_BLOCK(block_handler),
rb_cProc);
839 case block_handler_type_symbol:
840 case block_handler_type_proc:
841 return block_handler;
843 VM_UNREACHABLE(vm_block_handler_escape);
850 const VALUE *
const ep = cfp->ep;
853 VALUE *env_body, *env_ep;
854 int local_size, env_size;
856 if (VM_ENV_ESCAPED_P(ep)) {
857 return VM_ENV_ENVVAL(ep);
860 if (!VM_ENV_LOCAL_P(ep)) {
861 const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
862 if (!VM_ENV_ESCAPED_P(prev_ep)) {
865 while (prev_cfp->ep != prev_ep) {
866 prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(prev_cfp);
867 VM_ASSERT(prev_cfp->ep != NULL);
870 vm_make_env_each(ec, prev_cfp);
871 VM_FORCE_WRITE_SPECIAL_CONST(&ep[VM_ENV_DATA_INDEX_SPECVAL], VM_GUARDED_PREV_EP(prev_cfp->ep));
875 VALUE block_handler = VM_ENV_BLOCK_HANDLER(ep);
877 if (block_handler != VM_BLOCK_HANDLER_NONE) {
878 VALUE blockprocval = vm_block_handler_escape(ec, block_handler);
879 VM_STACK_ENV_WRITE(ep, VM_ENV_DATA_INDEX_SPECVAL, blockprocval);
883 if (!VM_FRAME_RUBYFRAME_P(cfp)) {
884 local_size = VM_ENV_DATA_SIZE;
887 local_size = ISEQ_BODY(cfp->iseq)->local_table_size + VM_ENV_DATA_SIZE;
902 env_size = local_size +
905 MEMCPY(env_body, ep - (local_size - 1 ),
VALUE, local_size);
908 for (i = 0; i < local_size; i++) {
909 if (VM_FRAME_RUBYFRAME_P(cfp)) {
911 ep[-local_size + i] = 0;
916 env_iseq = VM_FRAME_RUBYFRAME_P(cfp) ? cfp->iseq : NULL;
917 env_ep = &env_body[local_size - 1 ];
919 env = vm_env_new(env_ep, env_body, env_size, env_iseq);
922 VM_ENV_FLAGS_SET(env_ep, VM_ENV_FLAG_ESCAPED | VM_ENV_FLAG_WB_REQUIRED);
923 VM_STACK_ENV_WRITE(ep, 0, (
VALUE)env);
930 VALUE envval = vm_make_env_each(ec, cfp);
933 check_env_value((
const rb_env_t *)envval);
943 while ((cfp = rb_vm_get_binding_creatable_next_cfp(ec, cfp)) != 0) {
944 vm_make_env_object(ec, cfp);
945 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
950rb_vm_env_prev_env(
const rb_env_t *env)
952 const VALUE *ep = env->ep;
954 if (VM_ENV_LOCAL_P(ep)) {
958 const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
959 return VM_ENV_ENVVAL_PTR(prev_ep);
968 for (i = 0; i < ISEQ_BODY(iseq)->local_table_size; i++) {
969 local_var_list_add(vars, ISEQ_BODY(iseq)->local_table[i]);
978 if (VM_ENV_FLAGS(env->ep, VM_ENV_FLAG_ISOLATED))
break;
979 collect_local_variables_in_iseq(env->iseq, vars);
980 }
while ((env = rb_vm_env_prev_env(env)) != NULL);
986 if (VM_ENV_ESCAPED_P(ep)) {
987 collect_local_variables_in_env(VM_ENV_ENVVAL_PTR(ep), vars);
996rb_vm_env_local_variables(
const rb_env_t *env)
999 local_var_list_init(&vars);
1000 collect_local_variables_in_env(env, &vars);
1001 return local_var_list_finish(&vars);
1005rb_iseq_local_variables(
const rb_iseq_t *iseq)
1008 local_var_list_init(&vars);
1009 while (collect_local_variables_in_iseq(iseq, &vars)) {
1010 iseq = ISEQ_BODY(iseq)->parent_iseq;
1012 return local_var_list_finish(&vars);
1018vm_proc_create_from_captured(
VALUE klass,
1020 enum rb_block_type block_type,
1021 int8_t is_from_method, int8_t is_lambda)
1023 VALUE procval = rb_proc_alloc(klass);
1026 VM_ASSERT(VM_EP_IN_HEAP_P(GET_EC(), captured->ep));
1029 RB_OBJ_WRITE(procval, &proc->block.as.captured.code.val, captured->code.val);
1030 RB_OBJ_WRITE(procval, &proc->block.as.captured.self, captured->self);
1031 rb_vm_block_ep_update(procval, &proc->block, captured->ep);
1033 vm_block_type_set(&proc->block, block_type);
1034 proc->is_from_method = is_from_method;
1035 proc->is_lambda = is_lambda;
1044 switch (vm_block_type(src)) {
1045 case block_type_iseq:
1046 case block_type_ifunc:
1047 RB_OBJ_WRITE(obj, &dst->as.captured.self, src->as.captured.self);
1048 RB_OBJ_WRITE(obj, &dst->as.captured.code.val, src->as.captured.code.val);
1049 rb_vm_block_ep_update(obj, dst, src->as.captured.ep);
1051 case block_type_symbol:
1054 case block_type_proc:
1061proc_create(
VALUE klass,
const struct rb_block *block, int8_t is_from_method, int8_t is_lambda)
1063 VALUE procval = rb_proc_alloc(klass);
1066 VM_ASSERT(VM_EP_IN_HEAP_P(GET_EC(), vm_block_ep(block)));
1067 rb_vm_block_copy(procval, &proc->block, block);
1068 vm_block_type_set(&proc->block, block->type);
1069 proc->is_from_method = is_from_method;
1070 proc->is_lambda = is_lambda;
1076rb_proc_dup(
VALUE self)
1081 GetProcPtr(self, src);
1082 procval = proc_create(
rb_obj_class(self), &src->block, src->is_from_method, src->is_lambda);
1098 if (SIZEOF_VOIDP > SIZEOF_LONG)
1107 if (SIZEOF_VOIDP > SIZEOF_LONG)
1113static enum rb_id_table_iterator_result
1114collect_outer_variable_names(
ID id,
VALUE val,
void *ptr)
1118 if (
id == rb_intern(
"yield")) {
1123 if (data->isolate ||
1128 store = &data->read_only;
1130 if (*store ==
Qfalse) *store = rb_ary_new();
1131 rb_ary_push(*store, ID2NUM(
id));
1133 return ID_TABLE_CONTINUE;
1137env_copy(
const VALUE *src_ep,
VALUE read_only_variables)
1140 VM_ASSERT(src_env->ep == src_ep);
1143 VALUE *ep = &env_body[src_env->env_size - 2];
1146 if (read_only_variables) {
1147 for (
int i=RARRAY_LENINT(read_only_variables)-1; i>=0; i--) {
1150 for (
unsigned int j=0; j<ISEQ_BODY(src_env->iseq)->local_table_size; j++) {
1151 if (
id == ISEQ_BODY(src_env->iseq)->local_table[j]) {
1152 VALUE v = src_env->env[j];
1154 VALUE name = rb_id2str(
id);
1155 VALUE msg =
rb_sprintf(
"can not make shareable Proc because it can refer"
1156 " unshareable object %+" PRIsVALUE
" from ", v);
1158 rb_str_catf(msg,
"variable `%" PRIsVALUE
"'", name);
1164 rb_ary_delete_at(read_only_variables, i);
1171 ep[VM_ENV_DATA_INDEX_ME_CREF] = src_ep[VM_ENV_DATA_INDEX_ME_CREF];
1172 ep[VM_ENV_DATA_INDEX_FLAGS] = src_ep[VM_ENV_DATA_INDEX_FLAGS] | VM_ENV_FLAG_ISOLATED;
1174 if (!VM_ENV_LOCAL_P(src_ep)) {
1175 const VALUE *prev_ep = VM_ENV_PREV_EP(src_env->ep);
1176 const rb_env_t *new_prev_env = env_copy(prev_ep, read_only_variables);
1177 prev_env = (
VALUE)new_prev_env;
1178 ep[VM_ENV_DATA_INDEX_SPECVAL] = VM_GUARDED_PREV_EP(new_prev_env->ep);
1181 ep[VM_ENV_DATA_INDEX_SPECVAL] = VM_BLOCK_HANDLER_NONE;
1184 const rb_env_t *copied_env = vm_env_new(ep, env_body, src_env->env_size, src_env->iseq);
1193 const rb_env_t *env = env_copy(captured->ep, read_only_variables);
1194 *((
const VALUE **)&proc->block.as.captured.ep) = env->ep;
1199proc_shared_outer_variables(
struct rb_id_table *outer_variables,
bool isolate,
const char *message)
1207 rb_id_table_foreach(outer_variables, collect_outer_variable_names, (
void *)&data);
1209 if (data.ary !=
Qfalse) {
1210 VALUE str =
rb_sprintf(
"can not %s because it accesses outer variables", message);
1211 VALUE ary = data.ary;
1212 const char *sep =
" (";
1215 if (!name)
continue;
1224 else if (data.yield) {
1228 return data.read_only;
1232rb_proc_isolate_bang(
VALUE self)
1234 const rb_iseq_t *iseq = vm_proc_iseq(self);
1240 if (ISEQ_BODY(iseq)->outer_variables) {
1241 proc_shared_outer_variables(ISEQ_BODY(iseq)->outer_variables,
true,
"isolate a Proc");
1244 proc_isolate_env(self, proc,
Qfalse);
1245 proc->is_isolated = TRUE;
1253rb_proc_isolate(
VALUE self)
1255 VALUE dst = rb_proc_dup(self);
1256 rb_proc_isolate_bang(dst);
1261rb_proc_ractor_make_shareable(
VALUE self)
1263 const rb_iseq_t *iseq = vm_proc_iseq(self);
1271 "Proc's self is not shareable: %" PRIsVALUE,
1277 if (ISEQ_BODY(iseq)->outer_variables) {
1278 read_only_variables =
1279 proc_shared_outer_variables(ISEQ_BODY(iseq)->outer_variables,
false,
"make a Proc shareable");
1282 proc_isolate_env(self, proc, read_only_variables);
1283 proc->is_isolated = TRUE;
1290MJIT_FUNC_EXPORTED
VALUE
1295 if (!VM_ENV_ESCAPED_P(captured->ep)) {
1297 vm_make_env_object(ec, cfp);
1299 VM_ASSERT(VM_EP_IN_HEAP_P(ec, captured->ep));
1300 VM_ASSERT(imemo_type_p(captured->code.val, imemo_iseq) ||
1301 imemo_type_p(captured->code.val, imemo_ifunc));
1303 procval = vm_proc_create_from_captured(klass, captured,
1304 imemo_type(captured->code.val) == imemo_iseq ? block_type_iseq : block_type_ifunc, FALSE, is_lambda);
1315 VALUE bindval, envval;
1318 if (cfp == 0 || ruby_level_cfp == 0) {
1321 if (!VM_FRAME_RUBYFRAME_P(src_cfp) &&
1322 !VM_FRAME_RUBYFRAME_P(RUBY_VM_PREVIOUS_CONTROL_FRAME(src_cfp))) {
1326 envval = vm_make_env_object(ec, cfp);
1328 GetBindingPtr(bindval, bind);
1329 vm_bind_update_env(bindval, bind, envval);
1330 RB_OBJ_WRITE(bindval, &bind->block.as.captured.self, cfp->self);
1331 RB_OBJ_WRITE(bindval, &bind->block.as.captured.code.iseq, cfp->iseq);
1332 RB_OBJ_WRITE(bindval, &bind->pathobj, ISEQ_BODY(ruby_level_cfp->iseq)->location.pathobj);
1333 bind->first_lineno = rb_vm_get_sourceline(ruby_level_cfp);
1339rb_binding_add_dynavars(
VALUE bindval,
rb_binding_t *bind,
int dyncount,
const ID *dynvars)
1341 VALUE envval, pathobj = bind->pathobj;
1342 VALUE path = pathobj_path(pathobj);
1343 VALUE realpath = pathobj_realpath(pathobj);
1351 if (dyncount < 0)
return 0;
1353 base_block = &bind->block;
1354 base_iseq = vm_block_iseq(base_block);
1358 dyns->size = dyncount;
1359 MEMCPY(dyns->ids, dynvars,
ID, dyncount);
1361 rb_node_init(&tmp_node, NODE_SCOPE, (
VALUE)dyns, 0, 0);
1362 ast.root = &tmp_node;
1363 ast.compile_option = 0;
1364 ast.script_lines =
INT2FIX(-1);
1367 iseq = rb_iseq_new(&ast, ISEQ_BODY(base_iseq)->location.label, path, realpath, base_iseq, ISEQ_TYPE_EVAL);
1370 VALUE tempstr = rb_fstring_lit(
"<temp>");
1371 iseq = rb_iseq_new_top(&ast, tempstr, tempstr, tempstr, NULL);
1373 tmp_node.nd_tbl = 0;
1376 vm_set_eval_stack(ec, iseq, 0, base_block);
1377 vm_bind_update_env(bindval, bind, envval = vm_make_env_object(ec, ec->cfp));
1378 rb_vm_pop_frame(ec);
1389 int arg_size = ISEQ_BODY(iseq)->param.size;
1391 vm_push_frame(ec, iseq,
type | VM_FRAME_FLAG_FINISH, self,
1392 VM_GUARDED_PREV_EP(captured->ep),
1394 ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
1395 ec->cfp->sp + arg_size,
1396 ISEQ_BODY(iseq)->local_table_size - arg_size,
1397 ISEQ_BODY(iseq)->stack_max);
1398 return vm_exec(ec,
true);
1405 int arg_size = ISEQ_BODY(iseq)->param.size;
1408 VM_ASSERT(me->def->type == VM_METHOD_TYPE_BMETHOD);
1410 vm_push_frame(ec, iseq,
type | VM_FRAME_FLAG_BMETHOD, self,
1411 VM_GUARDED_PREV_EP(captured->ep),
1413 ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
1414 ec->cfp->sp + arg_size,
1415 ISEQ_BODY(iseq)->local_table_size - arg_size,
1416 ISEQ_BODY(iseq)->stack_max);
1418 VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);
1419 ret = vm_exec(ec,
true);
1424ALWAYS_INLINE(
static VALUE
1426 VALUE self,
int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler,
1431 VALUE self,
int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler,
1434 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
1436 VALUE type = VM_FRAME_MAGIC_BLOCK | (is_lambda ? VM_FRAME_FLAG_LAMBDA : 0);
1438 VALUE *sp = cfp->sp;
1442 CHECK_VM_STACK_OVERFLOW(cfp, argc);
1443 vm_check_canary(ec, sp);
1444 cfp->sp = sp + argc;
1445 for (i=0; i<argc; i++) {
1449 opt_pc = vm_yield_setup_args(ec, iseq, argc, sp, kw_splat, passed_block_handler,
1450 (is_lambda ? arg_setup_method : arg_setup_block));
1454 return invoke_block(ec, iseq, self, captured, cref,
type, opt_pc);
1457 return invoke_bmethod(ec, iseq, self, captured, me,
type, opt_pc);
1463 int argc,
const VALUE *argv,
1465 int is_lambda,
int force_blockarg)
1468 switch (vm_block_handler_type(block_handler)) {
1469 case block_handler_type_iseq:
1472 return invoke_iseq_block_from_c(ec, captured, captured->self,
1473 argc, argv, kw_splat, passed_block_handler,
1474 cref, is_lambda, NULL);
1476 case block_handler_type_ifunc:
1477 return vm_yield_with_cfunc(ec, VM_BH_TO_IFUNC_BLOCK(block_handler),
1478 VM_BH_TO_IFUNC_BLOCK(block_handler)->self,
1479 argc, argv, kw_splat, passed_block_handler, NULL);
1480 case block_handler_type_symbol:
1481 return vm_yield_with_symbol(ec, VM_BH_TO_SYMBOL(block_handler),
1482 argc, argv, kw_splat, passed_block_handler);
1483 case block_handler_type_proc:
1484 if (force_blockarg == FALSE) {
1485 is_lambda = block_proc_is_lambda(VM_BH_TO_PROC(block_handler));
1487 block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
1490 VM_UNREACHABLE(invoke_block_from_c_splattable);
1497 VALUE block_handler = VM_CF_BLOCK_HANDLER(ec->cfp);
1498 vm_block_handler_verify(block_handler);
1499 if (UNLIKELY(block_handler == VM_BLOCK_HANDLER_NONE)) {
1500 rb_vm_localjump_error(
"no block given",
Qnil, 0);
1503 return block_handler;
1509 return invoke_block_from_c_bh(ec, check_block_handler(ec),
1510 argc, argv, kw_splat, VM_BLOCK_HANDLER_NONE,
1511 cref, is_lambda, FALSE);
1517 return vm_yield_with_cref(ec, argc, argv, kw_splat, NULL, FALSE);
1523 return invoke_block_from_c_bh(ec, check_block_handler(ec),
1524 argc, argv, kw_splat, block_handler,
1525 NULL, FALSE, FALSE);
1531 return invoke_block_from_c_bh(ec, check_block_handler(ec), 1, &args,
1535ALWAYS_INLINE(
static VALUE
1538 int kw_splat,
VALUE passed_block_handler,
int is_lambda,
1544 int kw_splat,
VALUE passed_block_handler,
int is_lambda,
1547 const struct rb_block *block = &proc->block;
1550 switch (vm_block_type(block)) {
1551 case block_type_iseq:
1552 return invoke_iseq_block_from_c(ec, &block->as.captured, self, argc, argv, kw_splat, passed_block_handler, NULL, is_lambda, me);
1553 case block_type_ifunc:
1554 if (kw_splat == 1) {
1555 VALUE keyword_hash = argv[argc-1];
1556 if (!RB_TYPE_P(keyword_hash,
T_HASH)) {
1557 keyword_hash = rb_to_hash_type(keyword_hash);
1563 ((
VALUE *)argv)[argc-1] = rb_hash_dup(keyword_hash);
1566 return vm_yield_with_cfunc(ec, &block->as.captured, self, argc, argv, kw_splat, passed_block_handler, me);
1567 case block_type_symbol:
1568 return vm_yield_with_symbol(ec, block->as.symbol, argc, argv, kw_splat, passed_block_handler);
1569 case block_type_proc:
1570 is_lambda = block_proc_is_lambda(block->as.proc);
1571 block = vm_proc_block(block->as.proc);
1574 VM_UNREACHABLE(invoke_block_from_c_proc);
1580 int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler)
1582 return invoke_block_from_c_proc(ec, proc, self, argc, argv, kw_splat, passed_block_handler, proc->is_lambda, NULL);
1585MJIT_FUNC_EXPORTED
VALUE
1589 return invoke_block_from_c_proc(ec, proc, self, argc, argv, kw_splat, block_handler, TRUE, me);
1592MJIT_FUNC_EXPORTED
VALUE
1594 int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler)
1596 VALUE self = vm_block_self(&proc->block);
1597 vm_block_handler_verify(passed_block_handler);
1599 if (proc->is_from_method) {
1600 return rb_vm_invoke_bmethod(ec, proc, self, argc, argv, kw_splat, passed_block_handler, NULL);
1603 return vm_invoke_proc(ec, proc, self, argc, argv, kw_splat, passed_block_handler);
1609 int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler)
1611 vm_block_handler_verify(passed_block_handler);
1613 if (proc->is_from_method) {
1614 return rb_vm_invoke_bmethod(ec, proc, self, argc, argv, kw_splat, passed_block_handler, NULL);
1617 return vm_invoke_proc(ec, proc, self, argc, argv, kw_splat, passed_block_handler);
1626 while (cfp->pc == 0) {
1627 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
1628 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
1638 cfp = vm_normal_frame(ec, cfp);
1639 return lep_svar_get(ec, cfp ? VM_CF_LEP(cfp) : 0, key);
1645 cfp = vm_normal_frame(ec, cfp);
1646 lep_svar_set(ec, cfp ? VM_CF_LEP(cfp) : 0, key, val);
1652 return vm_cfp_svar_get(ec, ec->cfp, key);
1658 vm_cfp_svar_set(ec, ec->cfp, key, val);
1664 return vm_svar_get(GET_EC(), VM_SVAR_BACKREF);
1670 vm_svar_set(GET_EC(), VM_SVAR_BACKREF, val);
1676 return vm_svar_get(GET_EC(), VM_SVAR_LASTLINE);
1682 vm_svar_set(GET_EC(), VM_SVAR_LASTLINE, val);
1694 return RSTRING_PTR(rb_iseq_path(cfp->iseq));
1708 return rb_vm_get_sourceline(cfp);
1716rb_source_location(
int *pline)
1721 if (cfp && VM_FRAME_RUBYFRAME_P(cfp)) {
1722 if (pline) *pline = rb_vm_get_sourceline(cfp);
1723 return rb_iseq_path(cfp->iseq);
1726 if (pline) *pline = 0;
1731MJIT_FUNC_EXPORTED
const char *
1732rb_source_location_cstr(
int *pline)
1734 VALUE path = rb_source_location(pline);
1735 if (
NIL_P(path))
return NULL;
1736 return RSTRING_PTR(path);
1743 return vm_ec_cref(ec);
1747rb_vm_cref_replace_with_duplicated_cref(
void)
1751 rb_cref_t *cref = vm_cref_replace_with_duplicated_cref(cfp->ep);
1757rb_vm_cref_in_context(
VALUE self,
VALUE cbase)
1762 if (!cfp || cfp->self != self)
return NULL;
1763 if (!vm_env_cref_by_cref(cfp->ep))
return NULL;
1764 cref = vm_get_cref(cfp->ep);
1765 if (CREF_CLASS(cref) != cbase)
return NULL;
1774 dp(CREF_CLASS(cref));
1775 printf(
"%ld\n", CREF_VISI(cref));
1776 cref = CREF_NEXT(cref);
1790 return vm_get_cbase(cfp->ep);
1796make_localjump_error(
const char *mesg,
VALUE value,
int reason)
1827MJIT_FUNC_EXPORTED
void
1828rb_vm_localjump_error(
const char *mesg,
VALUE value,
int reason)
1830 VALUE exc = make_localjump_error(mesg, value, reason);
1835rb_vm_make_jump_tag_but_local_jump(
int state,
VALUE val)
1841 mesg =
"unexpected return";
1844 mesg =
"unexpected break";
1847 mesg =
"unexpected next";
1850 mesg =
"unexpected redo";
1854 mesg =
"retry outside of rescue clause";
1861 val = GET_EC()->tag->retval;
1863 return make_localjump_error(mesg, val, state);
1867rb_vm_jump_tag_but_local_jump(
int state)
1869 VALUE exc = rb_vm_make_jump_tag_but_local_jump(state,
Qundef);
1871 EC_JUMP_TAG(GET_EC(), state);
1877 while (VM_ENV_LOCAL_P(cfp->ep)) {
1878 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
1889 const VALUE *ep = VM_CF_PREV_EP(cfp);
1893 rb_vm_localjump_error(
"unexpected break", val, TAG_BREAK);
1896 ec->errinfo = (
VALUE)THROW_DATA_NEW(val, target_cfp, TAG_BREAK);
1897 EC_JUMP_TAG(ec, TAG_BREAK);
1903 vm_iter_break(GET_EC(),
Qnil);
1909 vm_iter_break(GET_EC(), val);
1914short ruby_vm_redefined_flag[BOP_LAST_];
1915static st_table *vm_opt_method_def_table = 0;
1916static st_table *vm_opt_mid_table = 0;
1919vm_redefinition_check_flag(
VALUE klass)
1921 if (klass ==
rb_cInteger)
return INTEGER_REDEFINED_OP_FLAG;
1922 if (klass ==
rb_cFloat)
return FLOAT_REDEFINED_OP_FLAG;
1923 if (klass ==
rb_cString)
return STRING_REDEFINED_OP_FLAG;
1924 if (klass ==
rb_cArray)
return ARRAY_REDEFINED_OP_FLAG;
1925 if (klass ==
rb_cHash)
return HASH_REDEFINED_OP_FLAG;
1926 if (klass ==
rb_cSymbol)
return SYMBOL_REDEFINED_OP_FLAG;
1928 if (klass ==
rb_cTime)
return TIME_REDEFINED_OP_FLAG;
1930 if (klass ==
rb_cRegexp)
return REGEXP_REDEFINED_OP_FLAG;
1931 if (klass ==
rb_cNilClass)
return NIL_REDEFINED_OP_FLAG;
1934 if (klass ==
rb_cProc)
return PROC_REDEFINED_OP_FLAG;
1939rb_vm_check_optimizable_mid(
VALUE mid)
1941 if (!vm_opt_mid_table) {
1945 return st_lookup(vm_opt_mid_table, mid, NULL);
1951 if (me->called_id != me->def->original_id) {
1956 switch (def->type) {
1957 case VM_METHOD_TYPE_CFUNC:
1958 case VM_METHOD_TYPE_OPTIMIZED:
1969 if (RB_TYPE_P(klass,
T_ICLASS) &&
FL_TEST(klass, RICLASS_IS_ORIGIN) &&
1970 RB_TYPE_P(RBASIC_CLASS(klass),
T_CLASS)) {
1971 klass = RBASIC_CLASS(klass);
1973 if (vm_redefinition_check_method_type(me)) {
1974 if (st_lookup(vm_opt_method_def_table, (st_data_t)me->def, &bop)) {
1975 int flag = vm_redefinition_check_flag(klass);
1977 rb_yjit_bop_redefined(flag, (
enum ruby_basic_operators)bop);
1978 rb_mjit_bop_redefined(flag, (
enum ruby_basic_operators)bop);
1979 ruby_vm_redefined_flag[bop] |= flag;
1985static enum rb_id_table_iterator_result
1986check_redefined_method(
ID mid,
VALUE value,
void *data)
1992 if (newme != me) rb_vm_check_redefinition_opt_method(me, me->owner);
1994 return ID_TABLE_CONTINUE;
1998rb_vm_check_redefinition_by_prepend(
VALUE klass)
2000 if (!vm_redefinition_check_flag(klass))
return;
2001 rb_id_table_foreach(RCLASS_M_TBL(RCLASS_ORIGIN(klass)), check_redefined_method, (
void *)klass);
2009 if (me && vm_redefinition_check_method_type(me)) {
2010 st_insert(vm_opt_method_def_table, (st_data_t)me->def, (st_data_t)bop);
2011 st_insert(vm_opt_mid_table, (st_data_t)mid, (st_data_t)
Qtrue);
2019vm_init_redefined_flag(
void)
2024 vm_opt_method_def_table = st_init_numtable();
2025 vm_opt_mid_table = st_init_numtable();
2027#define OP(mid_, bop_) (mid = id##mid_, bop = BOP_##bop_, ruby_vm_redefined_flag[bop] = 0)
2028#define C(k) add_opt_method(rb_c##k, mid, bop)
2029 OP(PLUS, PLUS), (C(Integer), C(Float), C(String), C(Array));
2030 OP(MINUS, MINUS), (C(Integer), C(Float));
2031 OP(MULT, MULT), (C(Integer), C(Float));
2032 OP(DIV, DIV), (C(Integer), C(Float));
2033 OP(MOD, MOD), (C(Integer), C(Float));
2034 OP(Eq, EQ), (C(Integer), C(Float), C(String), C(Symbol));
2035 OP(Eqq, EQQ), (C(Integer), C(Float), C(Symbol), C(String),
2036 C(NilClass), C(TrueClass), C(FalseClass));
2037 OP(LT, LT), (C(Integer), C(Float));
2038 OP(LE, LE), (C(Integer), C(Float));
2039 OP(GT, GT), (C(Integer), C(Float));
2040 OP(GE, GE), (C(Integer), C(Float));
2041 OP(LTLT, LTLT), (C(String), C(Array));
2042 OP(AREF, AREF), (C(Array), C(Hash), C(Integer));
2043 OP(ASET, ASET), (C(Array), C(Hash));
2044 OP(Length, LENGTH), (C(Array), C(String), C(Hash));
2045 OP(Size, SIZE), (C(Array), C(String), C(Hash));
2046 OP(EmptyP, EMPTY_P), (C(Array), C(String), C(Hash));
2047 OP(Succ, SUCC), (C(Integer), C(String));
2048 OP(EqTilde, MATCH), (C(
Regexp), C(String));
2049 OP(Freeze, FREEZE), (C(String));
2050 OP(UMinus, UMINUS), (C(String));
2051 OP(Max, MAX), (C(Array));
2052 OP(Min, MIN), (C(Array));
2053 OP(Call, CALL), (C(Proc));
2054 OP(And, AND), (C(Integer));
2055 OP(Or, OR), (C(Integer));
2056 OP(NilP,
NIL_P), (C(NilClass));
2057 OP(Cmp, CMP), (C(Integer), C(Float), C(String));
2058 OP(Default, DEFAULT), (C(Hash));
2069 switch (VM_FRAME_TYPE(cfp)) {
2070 case VM_FRAME_MAGIC_METHOD:
return "method";
2071 case VM_FRAME_MAGIC_BLOCK:
return "block";
2072 case VM_FRAME_MAGIC_CLASS:
return "class";
2073 case VM_FRAME_MAGIC_TOP:
return "top";
2074 case VM_FRAME_MAGIC_CFUNC:
return "cfunc";
2075 case VM_FRAME_MAGIC_IFUNC:
return "ifunc";
2076 case VM_FRAME_MAGIC_EVAL:
return "eval";
2077 case VM_FRAME_MAGIC_RESCUE:
return "rescue";
2087 if (THROW_DATA_P(err) &&
2088 THROW_DATA_STATE(err) == TAG_BREAK &&
2089 THROW_DATA_CONSUMED_P(err) == FALSE) {
2090 return THROW_DATA_VAL(err);
2102 unsigned long type = VM_FRAME_TYPE(cfp);
2103#define C(t) if (type == VM_FRAME_MAGIC_##t) return #t
2124 bool cfp_returning_with_value,
int state,
struct vm_throw_data *err)
2133 switch (VM_FRAME_TYPE(ec->cfp)) {
2134 case VM_FRAME_MAGIC_METHOD:
2135 RUBY_DTRACE_METHOD_RETURN_HOOK(ec, 0, 0);
2136 EXEC_EVENT_HOOK_AND_POP_FRAME(ec,
RUBY_EVENT_RETURN, ec->cfp->self, 0, 0, 0, frame_return_value(err));
2140 ec->cfp->self, 0, 0, 0, frame_return_value(err), TRUE);
2143 THROW_DATA_CONSUMED_SET(err);
2145 case VM_FRAME_MAGIC_BLOCK:
2146 if (VM_FRAME_BMETHOD_P(ec->cfp)) {
2147 VALUE bmethod_return_value = frame_return_value(err);
2148 if (cfp_returning_with_value) {
2150 bmethod_return_value = THROW_DATA_VAL(err);
2154 EXEC_EVENT_HOOK_AND_POP_FRAME(ec,
RUBY_EVENT_B_RETURN, ec->cfp->self, 0, 0, 0, bmethod_return_value);
2157 ec->cfp->self, 0, 0, 0, bmethod_return_value, TRUE);
2163 rb_vm_frame_method_entry(ec->cfp)->def->original_id,
2164 rb_vm_frame_method_entry(ec->cfp)->called_id,
2165 rb_vm_frame_method_entry(ec->cfp)->owner,
2166 bmethod_return_value);
2168 VM_ASSERT(me->def->type == VM_METHOD_TYPE_BMETHOD);
2169 local_hooks = me->def->body.bmethod.hooks;
2173 rb_vm_frame_method_entry(ec->cfp)->def->original_id,
2174 rb_vm_frame_method_entry(ec->cfp)->called_id,
2175 rb_vm_frame_method_entry(ec->cfp)->owner,
2176 bmethod_return_value, TRUE);
2178 THROW_DATA_CONSUMED_SET(err);
2181 EXEC_EVENT_HOOK_AND_POP_FRAME(ec,
RUBY_EVENT_B_RETURN, ec->cfp->self, 0, 0, 0, frame_return_value(err));
2184 ec->cfp->self, 0, 0, 0, frame_return_value(err), TRUE);
2186 THROW_DATA_CONSUMED_SET(err);
2189 case VM_FRAME_MAGIC_CLASS:
2284#if defined(__wasm__) && !defined(__EMSCRIPTEN__)
2286struct rb_vm_exec_context {
2291 enum ruby_tag_type state;
2297 struct rb_vm_tag *_tag,
bool skip_first_ex_handle) {
2298 if (skip_first_ex_handle) {
2302 ctx->result = ec->errinfo;
2303 rb_ec_raised_reset(ec, RAISED_STACKOVERFLOW | RAISED_NOMEMORY);
2304 while (UNDEF_P(ctx->result = vm_exec_handle_exception(ec, ctx->state, ctx->result, &ctx->initial))) {
2306 ctx->result = vm_exec_core(ec, ctx->initial);
2308 VM_ASSERT(ec->tag == _tag);
2310 if ((ctx->state = _tag->state) == TAG_NONE)
break;
2311 _tag->state = TAG_NONE;
2316vm_exec_bottom_main(
void *context)
2318 struct rb_vm_exec_context *ctx = (
struct rb_vm_exec_context *)context;
2320 ctx->state = TAG_NONE;
2321 if (!ctx->jit_enable_p || UNDEF_P(ctx->result = jit_exec(ctx->ec))) {
2322 ctx->result = vm_exec_core(ctx->ec, ctx->initial);
2324 vm_exec_enter_vm_loop(ctx->ec, ctx, ctx->tag,
true);
2328vm_exec_bottom_rescue(
void *context)
2330 struct rb_vm_exec_context *ctx = (
struct rb_vm_exec_context *)context;
2331 ctx->state = rb_ec_tag_state(ctx->ec);
2332 vm_exec_enter_vm_loop(ctx->ec, ctx, ctx->tag,
false);
2338 struct rb_vm_exec_context ctx = {
2340 .initial = 0, .result =
Qundef,
2341 .jit_enable_p = jit_enable_p,
2352 rb_wasm_try_catch_init(&try_catch, vm_exec_bottom_main, vm_exec_bottom_rescue, &ctx);
2354 rb_wasm_try_catch_loop_run(&try_catch, &_tag.buf);
2365 enum ruby_tag_type state;
2372 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
2373 if (!jit_enable_p || UNDEF_P(result = jit_exec(ec))) {
2374 result = vm_exec_core(ec, initial);
2379 result = ec->errinfo;
2380 rb_ec_raised_reset(ec, RAISED_STACKOVERFLOW | RAISED_NOMEMORY);
2381 while (UNDEF_P(result = vm_exec_handle_exception(ec, state, result, &initial))) {
2383 result = vm_exec_core(ec, initial);
2385 VM_ASSERT(ec->tag == &_tag);
2387 if ((state = _tag.state) == TAG_NONE)
break;
2388 _tag.state = TAG_NONE;
2406 unsigned long epc, cont_pc, cont_sp;
2412 cont_pc = cont_sp = 0;
2415 while (ec->cfp->pc == 0 || ec->cfp->iseq == 0) {
2416 if (UNLIKELY(VM_FRAME_TYPE(ec->cfp) == VM_FRAME_MAGIC_CFUNC)) {
2418 rb_vm_frame_method_entry(ec->cfp)->def->original_id,
2419 rb_vm_frame_method_entry(ec->cfp)->called_id,
2420 rb_vm_frame_method_entry(ec->cfp)->owner,
Qnil);
2421 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec,
2422 rb_vm_frame_method_entry(ec->cfp)->owner,
2423 rb_vm_frame_method_entry(ec->cfp)->def->original_id);
2425 rb_vm_pop_frame(ec);
2429 epc = cfp->pc - ISEQ_BODY(cfp->iseq)->iseq_encoded;
2432 if (state == TAG_BREAK || state == TAG_RETURN) {
2433 escape_cfp = THROW_DATA_CATCH_FRAME(err);
2435 if (cfp == escape_cfp) {
2436 if (state == TAG_RETURN) {
2437 if (!VM_FRAME_FINISHED_P(cfp)) {
2438 THROW_DATA_CATCH_FRAME_SET(err, cfp + 1);
2439 THROW_DATA_STATE_SET(err, state = TAG_BREAK);
2442 ct = ISEQ_BODY(cfp->iseq)->catch_table;
2443 if (ct)
for (i = 0; i < ct->size; i++) {
2444 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2445 if (entry->start < epc && entry->end >= epc) {
2446 if (entry->type == CATCH_TYPE_ENSURE) {
2447 catch_iseq = entry->iseq;
2448 cont_pc = entry->cont;
2449 cont_sp = entry->sp;
2454 if (catch_iseq == NULL) {
2456 THROW_DATA_CATCH_FRAME_SET(err, cfp + 1);
2458 hook_before_rewind(ec, ec->cfp,
true, state, err);
2459 rb_vm_pop_frame(ec);
2460 return THROW_DATA_VAL(err);
2467#if OPT_STACK_CACHING
2468 *initial = THROW_DATA_VAL(err);
2470 *ec->cfp->sp++ = THROW_DATA_VAL(err);
2478 if (state == TAG_RAISE) {
2479 ct = ISEQ_BODY(cfp->iseq)->catch_table;
2480 if (ct)
for (i = 0; i < ct->size; i++) {
2481 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2482 if (entry->start < epc && entry->end >= epc) {
2484 if (entry->type == CATCH_TYPE_RESCUE ||
2485 entry->type == CATCH_TYPE_ENSURE) {
2486 catch_iseq = entry->iseq;
2487 cont_pc = entry->cont;
2488 cont_sp = entry->sp;
2494 else if (state == TAG_RETRY) {
2495 ct = ISEQ_BODY(cfp->iseq)->catch_table;
2496 if (ct)
for (i = 0; i < ct->size; i++) {
2497 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2498 if (entry->start < epc && entry->end >= epc) {
2500 if (entry->type == CATCH_TYPE_ENSURE) {
2501 catch_iseq = entry->iseq;
2502 cont_pc = entry->cont;
2503 cont_sp = entry->sp;
2506 else if (entry->type == CATCH_TYPE_RETRY) {
2508 escape_cfp = THROW_DATA_CATCH_FRAME(err);
2509 if (cfp == escape_cfp) {
2510 cfp->pc = ISEQ_BODY(cfp->iseq)->iseq_encoded + entry->cont;
2518 else if ((state == TAG_BREAK && !escape_cfp) ||
2519 (state == TAG_REDO) ||
2520 (state == TAG_NEXT)) {
2521 type = (
const enum rb_catch_type[TAG_MASK]) {
2522 [TAG_BREAK] = CATCH_TYPE_BREAK,
2523 [TAG_NEXT] = CATCH_TYPE_NEXT,
2524 [TAG_REDO] = CATCH_TYPE_REDO,
2528 ct = ISEQ_BODY(cfp->iseq)->catch_table;
2529 if (ct)
for (i = 0; i < ct->size; i++) {
2530 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2532 if (entry->start < epc && entry->end >= epc) {
2533 if (entry->type == CATCH_TYPE_ENSURE) {
2534 catch_iseq = entry->iseq;
2535 cont_pc = entry->cont;
2536 cont_sp = entry->sp;
2539 else if (entry->type ==
type) {
2540 cfp->pc = ISEQ_BODY(cfp->iseq)->iseq_encoded + entry->cont;
2541 cfp->sp = vm_base_ptr(cfp) + entry->sp;
2543 if (state != TAG_REDO) {
2544#if OPT_STACK_CACHING
2545 *initial = THROW_DATA_VAL(err);
2547 *ec->cfp->sp++ = THROW_DATA_VAL(err);
2551 VM_ASSERT(ec->tag->state == TAG_NONE);
2558 ct = ISEQ_BODY(cfp->iseq)->catch_table;
2559 if (ct)
for (i = 0; i < ct->size; i++) {
2560 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2561 if (entry->start < epc && entry->end >= epc) {
2563 if (entry->type == CATCH_TYPE_ENSURE) {
2564 catch_iseq = entry->iseq;
2565 cont_pc = entry->cont;
2566 cont_sp = entry->sp;
2573 if (catch_iseq != NULL) {
2575 const int arg_size = 1;
2577 rb_iseq_check(catch_iseq);
2578 cfp->sp = vm_base_ptr(cfp) + cont_sp;
2579 cfp->pc = ISEQ_BODY(cfp->iseq)->iseq_encoded + cont_pc;
2582 cfp->sp[0] = (
VALUE)err;
2583 vm_push_frame(ec, catch_iseq, VM_FRAME_MAGIC_RESCUE,
2585 VM_GUARDED_PREV_EP(cfp->ep),
2587 ISEQ_BODY(catch_iseq)->iseq_encoded,
2588 cfp->sp + arg_size ,
2589 ISEQ_BODY(catch_iseq)->local_table_size - arg_size,
2590 ISEQ_BODY(catch_iseq)->stack_max);
2593 ec->tag->state = TAG_NONE;
2599 hook_before_rewind(ec, ec->cfp, (cfp == escape_cfp), state, err);
2601 if (VM_FRAME_FINISHED_P(ec->cfp)) {
2602 rb_vm_pop_frame(ec);
2603 ec->errinfo = (
VALUE)err;
2604 ec->tag = ec->tag->prev;
2605 EC_JUMP_TAG(ec, state);
2608 rb_vm_pop_frame(ec);
2621 vm_set_top_stack(ec, iseq);
2622 val = vm_exec(ec,
true);
2632 vm_set_main_stack(ec, iseq);
2633 val = vm_exec(ec,
true);
2643 if (idp) *idp = me->def->original_id;
2644 if (called_idp) *called_idp = me->called_id;
2645 if (klassp) *klassp = me->owner;
2656 return rb_vm_control_frame_id_and_class(ec->cfp, idp, called_idp, klassp);
2662 return rb_ec_frame_method_id_and_class(GET_EC(), idp, 0, klassp);
2671 const rb_iseq_t *iseq = rb_iseq_new(0, filename, filename,
Qnil, 0, ISEQ_TYPE_TOP);
2674 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_TOP | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH,
2675 recv, block_handler,
2676 (
VALUE)vm_cref_new_toplevel(ec),
2677 0, reg_cfp->sp, 0, 0);
2681 rb_vm_pop_frame(ec);
2688rb_vm_update_references(
void *ptr)
2693 rb_gc_update_tbl_refs(vm->frozen_strings);
2694 vm->mark_object_ary = rb_gc_location(vm->mark_object_ary);
2695 vm->load_path = rb_gc_location(vm->load_path);
2696 vm->load_path_snapshot = rb_gc_location(vm->load_path_snapshot);
2698 if (vm->load_path_check_cache) {
2699 vm->load_path_check_cache = rb_gc_location(vm->load_path_check_cache);
2702 vm->expanded_load_path = rb_gc_location(vm->expanded_load_path);
2703 vm->loaded_features = rb_gc_location(vm->loaded_features);
2704 vm->loaded_features_snapshot = rb_gc_location(vm->loaded_features_snapshot);
2705 vm->loaded_features_realpaths = rb_gc_location(vm->loaded_features_realpaths);
2706 vm->top_self = rb_gc_location(vm->top_self);
2707 vm->orig_progname = rb_gc_location(vm->orig_progname);
2709 rb_gc_update_tbl_refs(vm->overloaded_cme_table);
2711 if (vm->coverages) {
2712 vm->coverages = rb_gc_location(vm->coverages);
2713 vm->me2counter = rb_gc_location(vm->me2counter);
2719rb_vm_each_stack_value(
void *ptr,
void (*cb)(
VALUE,
void*),
void *ctx)
2724 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
2725 VM_ASSERT(rb_ractor_status_p(r, ractor_blocking) ||
2726 rb_ractor_status_p(r, ractor_running));
2727 if (r->threads.cnt > 0) {
2729 ccan_list_for_each(&r->threads.set, th, lt_node) {
2730 VM_ASSERT(th != NULL);
2733 VALUE *p = ec->vm_stack;
2734 VALUE *sp = ec->cfp->sp;
2748static enum rb_id_table_iterator_result
2749vm_mark_negative_cme(
VALUE val,
void *dmy)
2752 return ID_TABLE_CONTINUE;
2756rb_vm_mark(
void *ptr)
2758 RUBY_MARK_ENTER(
"vm");
2759 RUBY_GC_INFO(
"-------------------------------------------------\n");
2764 const VALUE *obj_ary;
2766 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
2768 VM_ASSERT(rb_ractor_status_p(r, ractor_blocking) ||
2769 rb_ractor_status_p(r, ractor_running));
2770 rb_gc_mark(rb_ractor_self(r));
2773 rb_gc_mark_movable(vm->mark_object_ary);
2777 for (i=0; i < len; i++) {
2781 rb_gc_mark(*obj_ary);
2784 for (j=0; j < jlen; j++) {
2790 rb_gc_mark_movable(vm->load_path);
2791 rb_gc_mark_movable(vm->load_path_snapshot);
2792 RUBY_MARK_MOVABLE_UNLESS_NULL(vm->load_path_check_cache);
2793 rb_gc_mark_movable(vm->expanded_load_path);
2794 rb_gc_mark_movable(vm->loaded_features);
2795 rb_gc_mark_movable(vm->loaded_features_snapshot);
2796 rb_gc_mark_movable(vm->loaded_features_realpaths);
2797 rb_gc_mark_movable(vm->top_self);
2798 rb_gc_mark_movable(vm->orig_progname);
2799 RUBY_MARK_MOVABLE_UNLESS_NULL(vm->coverages);
2800 RUBY_MARK_MOVABLE_UNLESS_NULL(vm->me2counter);
2802 rb_mark_tbl(vm->defined_module_hash);
2804 if (vm->loading_table) {
2805 rb_mark_tbl(vm->loading_table);
2808 rb_gc_mark_values(RUBY_NSIG, vm->trap_list.cmd);
2810 rb_id_table_foreach_values(vm->negative_cme_table, vm_mark_negative_cme, NULL);
2811 rb_mark_tbl_no_pin(vm->overloaded_cme_table);
2812 for (i=0; i<VM_GLOBAL_CC_CACHE_TABLE_SIZE; i++) {
2813 const struct rb_callcache *cc = vm->global_cc_cache_table[i];
2816 if (!vm_cc_invalidated_p(cc)) {
2817 rb_gc_mark((
VALUE)cc);
2820 vm->global_cc_cache_table[i] = NULL;
2828 RUBY_MARK_LEAVE(
"vm");
2831#undef rb_vm_register_special_exception
2833rb_vm_register_special_exception_str(
enum ruby_special_exceptions sp,
VALUE cls,
VALUE mesg)
2838 ((
VALUE *)vm->special_exceptions)[sp] = exc;
2839 rb_gc_register_mark_object(exc);
2843rb_vm_add_root_module(
VALUE module)
2847 st_insert(vm->defined_module_hash, (st_data_t)module, (st_data_t)module);
2853free_loading_table_entry(st_data_t key, st_data_t value, st_data_t arg)
2862 RUBY_FREE_ENTER(
"vm");
2867 vm->ractor.main_thread = NULL;
2870 rb_fiber_reset_root_local_storage(th);
2873 rb_vm_living_threads_init(vm);
2874 ruby_vm_run_at_exit_hooks(vm);
2875 if (vm->loading_table) {
2876 st_foreach(vm->loading_table, free_loading_table_entry, 0);
2877 st_free_table(vm->loading_table);
2878 vm->loading_table = 0;
2880 if (vm->frozen_strings) {
2881 st_free_table(vm->frozen_strings);
2882 vm->frozen_strings = 0;
2884 RB_ALTSTACK_FREE(vm->main_altstack);
2886 rb_objspace_free(objspace);
2892 ruby_current_vm_ptr = NULL;
2894 RUBY_FREE_LEAVE(
"vm");
2898size_t rb_vm_memsize_waiting_list(
struct ccan_list_head *waiting_list);
2899size_t rb_vm_memsize_waiting_fds(
struct ccan_list_head *waiting_fds);
2900size_t rb_vm_memsize_postponed_job_buffer(
void);
2905static enum rb_id_table_iterator_result
2906vm_memsize_constant_cache_i(
ID id,
VALUE ics,
void *size)
2908 *((
size_t *) size) += rb_st_memsize((
st_table *) ics);
2909 return ID_TABLE_CONTINUE;
2916vm_memsize_constant_cache(
void)
2919 size_t size = rb_id_table_memsize(vm->constant_cache);
2921 rb_id_table_foreach(vm->constant_cache, vm_memsize_constant_cache_i, &size);
2932 at_exit = at_exit->next;
2941vm_memsize_builtin_function_table(
const struct rb_builtin_function *builtin_function_table)
2949vm_memsize(
const void *ptr)
2955 rb_vm_memsize_waiting_list(&vm->waiting_pids) +
2956 rb_vm_memsize_waiting_list(&vm->waiting_grps) +
2957 rb_vm_memsize_waiting_fds(&vm->waiting_fds) +
2958 rb_st_memsize(vm->loaded_features_index) +
2959 rb_st_memsize(vm->loading_table) +
2960 rb_st_memsize(vm->ensure_rollback_table) +
2961 rb_vm_memsize_postponed_job_buffer() +
2962 rb_vm_memsize_workqueue(&vm->workqueue) +
2963 rb_st_memsize(vm->defined_module_hash) +
2964 vm_memsize_at_exit_list(vm->at_exit) +
2965 rb_st_memsize(vm->frozen_strings) +
2966 vm_memsize_builtin_function_table(vm->builtin_function_table) +
2967 rb_id_table_memsize(vm->negative_cme_table) +
2968 rb_st_memsize(vm->overloaded_cme_table) +
2969 vm_memsize_constant_cache()
2980 {0, 0, vm_memsize,},
2981 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
2986vm_default_params(
void)
2989 VALUE result = rb_hash_new_with_size(4);
2990#define SET(name) rb_hash_aset(result, ID2SYM(rb_intern(#name)), SIZET2NUM(vm->default_params.name));
2991 SET(thread_vm_stack_size);
2992 SET(thread_machine_stack_size);
2993 SET(fiber_vm_stack_size);
2994 SET(fiber_machine_stack_size);
3001get_param(
const char *name,
size_t default_value,
size_t min_value)
3004 size_t result = default_value;
3005 if ((envval = getenv(name)) != 0) {
3006 long val = atol(envval);
3007 if (val < (
long)min_value) {
3008 val = (long)min_value;
3010 result = (size_t)(((val -1 + RUBY_VM_SIZE_ALIGN) / RUBY_VM_SIZE_ALIGN) * RUBY_VM_SIZE_ALIGN);
3012 if (0) ruby_debug_printf(
"%s: %"PRIuSIZE
"\n", name, result);
3018check_machine_stack_size(
size_t *sizep)
3020#ifdef PTHREAD_STACK_MIN
3021 size_t size = *sizep;
3024#ifdef PTHREAD_STACK_MIN
3025 if (size < (
size_t)PTHREAD_STACK_MIN) {
3026 *sizep = (size_t)PTHREAD_STACK_MIN * 2;
3032vm_default_params_setup(
rb_vm_t *vm)
3034 vm->default_params.thread_vm_stack_size =
3035 get_param(
"RUBY_THREAD_VM_STACK_SIZE",
3036 RUBY_VM_THREAD_VM_STACK_SIZE,
3037 RUBY_VM_THREAD_VM_STACK_SIZE_MIN);
3039 vm->default_params.thread_machine_stack_size =
3040 get_param(
"RUBY_THREAD_MACHINE_STACK_SIZE",
3041 RUBY_VM_THREAD_MACHINE_STACK_SIZE,
3042 RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN);
3044 vm->default_params.fiber_vm_stack_size =
3045 get_param(
"RUBY_FIBER_VM_STACK_SIZE",
3046 RUBY_VM_FIBER_VM_STACK_SIZE,
3047 RUBY_VM_FIBER_VM_STACK_SIZE_MIN);
3049 vm->default_params.fiber_machine_stack_size =
3050 get_param(
"RUBY_FIBER_MACHINE_STACK_SIZE",
3051 RUBY_VM_FIBER_MACHINE_STACK_SIZE,
3052 RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN);
3055 check_machine_stack_size(&vm->default_params.thread_machine_stack_size);
3056 check_machine_stack_size(&vm->default_params.fiber_machine_stack_size);
3063 rb_vm_living_threads_init(vm);
3064 vm->thread_report_on_exception = 1;
3065 vm->src_encoding_index = -1;
3067 vm_default_params_setup(vm);
3077 VALUE *p = ec->vm_stack;
3078 VALUE *sp = ec->cfp->sp;
3082 for (i = 0; i < (long)(sp - p); i++) {
3084 VALUE update = rb_gc_location(ref);
3085 if (ref != update) {
3090 while (cfp != limit_cfp) {
3091 const VALUE *ep = cfp->ep;
3092 cfp->self = rb_gc_location(cfp->self);
3094 cfp->block_code = (
void *)rb_gc_location((
VALUE)cfp->block_code);
3096 if (!VM_ENV_LOCAL_P(ep)) {
3097 const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
3098 if (VM_ENV_FLAGS(prev_ep, VM_ENV_FLAG_ESCAPED)) {
3099 VM_FORCE_WRITE(&prev_ep[VM_ENV_DATA_INDEX_ENV], rb_gc_location(prev_ep[VM_ENV_DATA_INDEX_ENV]));
3102 if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED)) {
3103 VM_FORCE_WRITE(&ep[VM_ENV_DATA_INDEX_ENV], rb_gc_location(ep[VM_ENV_DATA_INDEX_ENV]));
3104 VM_FORCE_WRITE(&ep[VM_ENV_DATA_INDEX_ME_CREF], rb_gc_location(ep[VM_ENV_DATA_INDEX_ME_CREF]));
3108 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
3112 ec->storage = rb_gc_location(ec->storage);
3115static enum rb_id_table_iterator_result
3116mark_local_storage_i(
VALUE local,
void *data)
3119 return ID_TABLE_CONTINUE;
3128 VALUE *p = ec->vm_stack;
3129 VALUE *sp = ec->cfp->sp;
3133 VM_ASSERT(sp == ec->cfp->sp);
3134 rb_gc_mark_vm_stack_values((
long)(sp - p), p);
3136 while (cfp != limit_cfp) {
3137 const VALUE *ep = cfp->ep;
3138 VM_ASSERT(!!VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED) == vm_ep_in_heap_p_(ec, ep));
3140 if (VM_FRAME_TYPE(cfp) != VM_FRAME_MAGIC_DUMMY) {
3141 rb_gc_mark_movable(cfp->self);
3142 rb_gc_mark_movable((
VALUE)cfp->iseq);
3143 rb_gc_mark_movable((
VALUE)cfp->block_code);
3145 if (!VM_ENV_LOCAL_P(ep)) {
3146 const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
3147 if (VM_ENV_FLAGS(prev_ep, VM_ENV_FLAG_ESCAPED)) {
3148 rb_gc_mark_movable(prev_ep[VM_ENV_DATA_INDEX_ENV]);
3151 if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED)) {
3152 rb_gc_mark_movable(ep[VM_ENV_DATA_INDEX_ENV]);
3153 rb_gc_mark(ep[VM_ENV_DATA_INDEX_ME_CREF]);
3158 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
3163 if (ec->machine.stack_start && ec->machine.stack_end &&
3166 rb_gc_mark_machine_stack(ec);
3167 rb_gc_mark_locations((
VALUE *)&ec->machine.regs,
3168 (
VALUE *)(&ec->machine.regs) +
3169 sizeof(ec->machine.regs) / (
sizeof(
VALUE)));
3172 RUBY_MARK_UNLESS_NULL(ec->errinfo);
3173 RUBY_MARK_UNLESS_NULL(ec->root_svar);
3174 if (ec->local_storage) {
3175 rb_id_table_foreach_values(ec->local_storage, mark_local_storage_i, NULL);
3177 RUBY_MARK_UNLESS_NULL(ec->local_storage_recursive_hash);
3178 RUBY_MARK_UNLESS_NULL(ec->local_storage_recursive_hash_for_trace);
3179 RUBY_MARK_UNLESS_NULL(ec->private_const_reference);
3181 RUBY_MARK_MOVABLE_UNLESS_NULL(ec->storage);
3186void rb_threadptr_root_fiber_setup(
rb_thread_t *th);
3187void rb_threadptr_root_fiber_release(
rb_thread_t *th);
3190thread_compact(
void *ptr)
3194 th->self = rb_gc_location(th->self);
3196 if (!th->root_fiber) {
3197 rb_execution_context_update(th->ec);
3202thread_mark(
void *ptr)
3205 RUBY_MARK_ENTER(
"thread");
3206 rb_fiber_mark_self(th->ec->fiber_ptr);
3209 switch (th->invoke_type) {
3210 case thread_invoke_type_proc:
3211 case thread_invoke_type_ractor_proc:
3212 RUBY_MARK_UNLESS_NULL(th->invoke_arg.proc.proc);
3213 RUBY_MARK_UNLESS_NULL(th->invoke_arg.proc.args);
3215 case thread_invoke_type_func:
3216 rb_gc_mark_maybe((
VALUE)th->invoke_arg.func.arg);
3222 rb_gc_mark(rb_ractor_self(th->ractor));
3223 RUBY_MARK_UNLESS_NULL(th->thgroup);
3224 RUBY_MARK_UNLESS_NULL(th->value);
3225 RUBY_MARK_UNLESS_NULL(th->pending_interrupt_queue);
3226 RUBY_MARK_UNLESS_NULL(th->pending_interrupt_mask_stack);
3227 RUBY_MARK_UNLESS_NULL(th->top_self);
3228 RUBY_MARK_UNLESS_NULL(th->top_wrapper);
3229 if (th->root_fiber) rb_fiber_mark_self(th->root_fiber);
3231 RUBY_ASSERT(th->ec == rb_fiberptr_get_ec(th->ec->fiber_ptr));
3232 RUBY_MARK_UNLESS_NULL(th->stat_insn_usage);
3233 RUBY_MARK_UNLESS_NULL(th->last_status);
3234 RUBY_MARK_UNLESS_NULL(th->locking_mutex);
3235 RUBY_MARK_UNLESS_NULL(th->name);
3237 RUBY_MARK_UNLESS_NULL(th->scheduler);
3239 RUBY_MARK_LEAVE(
"thread");
3243thread_free(
void *ptr)
3246 RUBY_FREE_ENTER(
"thread");
3248 if (th->locking_mutex !=
Qfalse) {
3249 rb_bug(
"thread_free: locking_mutex must be NULL (%p:%p)", (
void *)th, (
void *)th->locking_mutex);
3251 if (th->keeping_mutexes != NULL) {
3252 rb_bug(
"thread_free: keeping_mutexes must be NULL (%p:%p)", (
void *)th, (
void *)th->keeping_mutexes);
3255 rb_threadptr_root_fiber_release(th);
3257 if (th->vm && th->vm->ractor.main_thread == th) {
3258 RUBY_GC_INFO(
"MRI main thread\n");
3265 RUBY_FREE_LEAVE(
"thread");
3269thread_memsize(
const void *ptr)
3274 if (!th->root_fiber) {
3275 size += th->ec->vm_stack_size *
sizeof(
VALUE);
3277 if (th->ec->local_storage) {
3278 size += rb_id_table_memsize(th->ec->local_storage);
3283#define thread_data_type ruby_threadptr_data_type
3292 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
3296rb_obj_is_thread(
VALUE obj)
3302thread_alloc(
VALUE klass)
3311 ec->vm_stack = stack;
3312 ec->vm_stack_size = size;
3318 rb_ec_set_vm_stack(ec, stack, size);
3320 ec->cfp = (
void *)(ec->vm_stack + ec->vm_stack_size);
3324 VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH | VM_FRAME_FLAG_CFRAME ,
3325 Qnil , VM_BLOCK_HANDLER_NONE ,
3327 0 , ec->vm_stack, 0, 0
3334 rb_ec_set_vm_stack(ec, NULL, 0);
3345 rb_threadptr_root_fiber_setup(th);
3349 th->scheduler =
Qnil;
3352 size_t size = vm->default_params.thread_vm_stack_size /
sizeof(
VALUE);
3353 rb_ec_initialize_vm_stack(th->ec,
ALLOC_N(
VALUE, size), size);
3356 VM_ASSERT(th->ec->cfp == NULL);
3357 VM_ASSERT(th->ec->vm_stack == NULL);
3358 VM_ASSERT(th->ec->vm_stack_size == 0);
3361 th->status = THREAD_RUNNABLE;
3362 th->last_status =
Qnil;
3363 th->top_wrapper = 0;
3364 th->top_self = vm->top_self;
3367 th->ec->errinfo =
Qnil;
3368 th->ec->root_svar =
Qfalse;
3369 th->ec->local_storage_recursive_hash =
Qnil;
3370 th->ec->local_storage_recursive_hash_for_trace =
Qnil;
3372 th->ec->storage =
Qnil;
3374#if OPT_CALL_THREADED_CODE
3378 th->report_on_exception = vm->thread_report_on_exception;
3379 th->ext_config.ractor_safe =
true;
3381#if USE_RUBY_DEBUG_LOG
3388rb_thread_alloc(
VALUE klass)
3390 VALUE self = thread_alloc(klass);
3392 target_th->ractor = GET_RACTOR();
3393 th_init(target_th, self, target_th->vm = GET_VM());
3397#define REWIND_CFP(expr) do { \
3398 rb_execution_context_t *ec__ = GET_EC(); \
3399 VALUE *const curr_sp = (ec__->cfp++)->sp; \
3400 VALUE *const saved_sp = ec__->cfp->sp; \
3401 ec__->cfp->sp = curr_sp; \
3403 (ec__->cfp--)->sp = saved_sp; \
3430 rb_clear_method_cache(self, mid);
3436m_core_set_postexe(
VALUE self)
3445core_hash_merge(
VALUE hash,
long argc,
const VALUE *argv)
3447 Check_Type(hash,
T_HASH);
3448 VM_ASSERT(argc % 2 == 0);
3449 rb_hash_bulk_insert(argc, argv, hash);
3454m_core_hash_merge_ptr(
int argc,
VALUE *argv,
VALUE recv)
3456 VALUE hash = argv[0];
3458 REWIND_CFP(hash = core_hash_merge(hash, argc-1, argv+1));
3466 rb_hash_aset(hash, key, value);
3473 REWIND_CFP(hash = core_hash_merge_kwd(hash, kw));
3484m_core_make_shareable_copy(
VALUE recv,
VALUE obj)
3492 return rb_ractor_ensure_shareable(obj, name);
3498 rb_hash_foreach(rb_to_hash_type(kw), kwmerge_i, hash);
3502extern VALUE *rb_gc_stack_start;
3503extern size_t rb_gc_stack_maxsize;
3511 rb_vm_bugreport(NULL);
3519 VALUE ary = rb_ary_new();
3520#ifdef HAVE_BACKTRACE
3521#include <execinfo.h>
3522#define MAX_NATIVE_TRACE 1024
3523 static void *trace[MAX_NATIVE_TRACE];
3524 int n = (int)backtrace(trace, MAX_NATIVE_TRACE);
3525 char **syms = backtrace_symbols(trace, n);
3532 for (i=0; i<n; i++) {
3540#if VM_COLLECT_USAGE_DETAILS
3541static VALUE usage_analysis_insn_start(
VALUE self);
3542static VALUE usage_analysis_operand_start(
VALUE self);
3543static VALUE usage_analysis_register_start(
VALUE self);
3544static VALUE usage_analysis_insn_stop(
VALUE self);
3545static VALUE usage_analysis_operand_stop(
VALUE self);
3546static VALUE usage_analysis_register_stop(
VALUE self);
3547static VALUE usage_analysis_insn_running(
VALUE self);
3548static VALUE usage_analysis_operand_running(
VALUE self);
3549static VALUE usage_analysis_register_running(
VALUE self);
3550static VALUE usage_analysis_insn_clear(
VALUE self);
3551static VALUE usage_analysis_operand_clear(
VALUE self);
3552static VALUE usage_analysis_register_clear(
VALUE self);
3558 return rb_f_raise(c, v);
3605vm_keep_script_lines(
VALUE self)
3607 return RBOOL(ruby_vm_keep_script_lines);
3622vm_keep_script_lines_set(
VALUE self,
VALUE flags)
3624 ruby_vm_keep_script_lines =
RTEST(flags);
3653#if USE_DEBUG_COUNTER
3674 rb_define_method(klass,
"make_shareable_copy", m_core_make_shareable_copy, 1);
3677 RBASIC_CLEAR_CLASS(klass);
3679 rb_gc_register_mark_object(fcore);
3680 rb_mRubyVMFrozenCore = fcore;
3843#if VM_COLLECT_USAGE_DETAILS
3845#define define_usage_analysis_hash(name) \
3846 rb_define_const(rb_cRubyVM, "USAGE_ANALYSIS_" #name, rb_hash_new())
3847 define_usage_analysis_hash(
INSN);
3848 define_usage_analysis_hash(REGS);
3849 define_usage_analysis_hash(INSN_BIGRAM);
3871#if OPT_DIRECT_THREADED_CODE
3872 rb_ary_push(opts,
rb_str_new2(
"direct threaded code"));
3873#elif OPT_TOKEN_THREADED_CODE
3874 rb_ary_push(opts,
rb_str_new2(
"token threaded code"));
3875#elif OPT_CALL_THREADED_CODE
3876 rb_ary_push(opts,
rb_str_new2(
"call threaded code"));
3879#if OPT_STACK_CACHING
3882#if OPT_OPERANDS_UNIFICATION
3883 rb_ary_push(opts,
rb_str_new2(
"operands unification"));
3885#if OPT_INSTRUCTIONS_UNIFICATION
3886 rb_ary_push(opts,
rb_str_new2(
"instructions unification"));
3888#if OPT_INLINE_METHOD_CACHE
3889 rb_ary_push(opts,
rb_str_new2(
"inline method cache"));
3891#if OPT_BLOCKINLINING
3899 rb_define_const(rb_cRubyVM,
"INSTRUCTION_NAMES", rb_insns_name_array());
3924 rb_vm_t *vm = ruby_current_vm_ptr;
3926 VALUE filename = rb_fstring_lit(
"<main>");
3927 const rb_iseq_t *iseq = rb_iseq_new(0, filename, filename,
Qnil, 0, ISEQ_TYPE_TOP);
3930 rb_ractor_main_setup(vm, th->ractor, th);
3937 vm->ractor.main_thread = th;
3938 vm->ractor.main_ractor = th->ractor;
3940 th->top_wrapper = 0;
3941 th->top_self = rb_vm_top_self();
3943 rb_gc_register_mark_object((
VALUE)iseq);
3944 th->ec->cfp->iseq = iseq;
3945 th->ec->cfp->pc = ISEQ_BODY(iseq)->iseq_encoded;
3946 th->ec->cfp->self = th->top_self;
3948 VM_ENV_FLAGS_UNSET(th->ec->cfp->ep, VM_FRAME_FLAG_CFRAME);
3949 VM_STACK_ENV_WRITE(th->ec->cfp->ep, VM_ENV_DATA_INDEX_ME_CREF, (
VALUE)vm_cref_new(
rb_cObject, METHOD_VISI_PRIVATE, FALSE, NULL, FALSE, FALSE));
3956 rb_objspace_gc_enable(vm->objspace);
3958 vm_init_redefined_flag();
3962 OPTIMIZED_METHOD_TYPE_BLOCK_CALL, 0, METHOD_VISI_PUBLIC);
3964 rb_gc_register_mark_object(rb_block_param_proxy);
3967 Init_vm_backtrace();
3971rb_vm_set_progname(
VALUE filename)
3977 rb_iseq_pathobj_set(cfp->iseq,
rb_str_dup(filename), rb_iseq_realpath(cfp->iseq));
3986 rb_vm_t * vm = ruby_mimmalloc(
sizeof(*vm));
3989 fputs(
"[FATAL] failed to allocate memory\n", stderr);
3997 vm->objspace = rb_objspace_alloc();
3998 ruby_current_vm_ptr = vm;
3999 vm->negative_cme_table = rb_id_table_create(16);
4000 vm->overloaded_cme_table = st_init_numtable();
4001 vm->constant_cache = rb_id_table_create(0);
4006 th->ractor = vm->ractor.main_ractor = rb_ractor_main_alloc();
4007 Init_native_thread(th);
4010 rb_ractor_set_current_ec(th->ractor, th->ec);
4011 ruby_thread_init_stack(th);
4021#include <sys/mman.h>
4025Init_vm_objects(
void)
4029 vm->defined_module_hash = st_init_numtable();
4032 vm->mark_object_ary = rb_ary_hidden_new(128);
4033 vm->loading_table = st_init_strtable();
4034 vm->frozen_strings = st_init_table_with_size(&rb_fstring_hash_type, 10000);
4036 vm->static_ext_inits = st_init_strtable();
4041 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
4042 if (vm->shape_list == MAP_FAILED) {
4049 if (!vm->shape_list) {
4056void Init_builtin_yjit(
void) {}
4070 return GET_VM()->top_self;
4087 return &cr->verbose;
4100 int len,
size_t pos,
VALUE *pnop,
VALUE child);
4103rb_vm_fstring_table(
void)
4105 return GET_VM()->frozen_strings;
4108#if VM_COLLECT_USAGE_DETAILS
4110#define HASH_ASET(h, k, v) rb_hash_aset((h), (st_data_t)(k), (st_data_t)(v))
4124vm_analysis_insn(
int insn)
4128 static int prev_insn = -1;
4134 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
4135 CONST_ID(bigram_hash,
"USAGE_ANALYSIS_INSN_BIGRAM");
4138 ihash = rb_hash_new();
4139 HASH_ASET(uh,
INT2FIX(insn), ihash);
4147 if (prev_insn != -1) {
4157 if (
NIL_P(cv = rb_hash_aref(uh, bi))) {
4166vm_analysis_operand(
int insn,
int n,
VALUE op)
4176 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
4180 ihash = rb_hash_new();
4181 HASH_ASET(uh,
INT2FIX(insn), ihash);
4184 ophash = rb_hash_new();
4185 HASH_ASET(ihash,
INT2FIX(n), ophash);
4188 valstr = rb_insn_operand_intern(GET_EC()->cfp->iseq, insn, n, op, 0, 0, 0, 0);
4191 if (
NIL_P(cv = rb_hash_aref(ophash, valstr))) {
4198vm_analysis_register(
int reg,
int isset)
4203 static const char regstrs[][5] = {
4211 static const char getsetstr[][4] = {
4215 static VALUE syms[
sizeof(regstrs) /
sizeof(regstrs[0])][2];
4219 CONST_ID(usage_hash,
"USAGE_ANALYSIS_REGS");
4224 for (i = 0; i < (int)(
sizeof(regstrs) /
sizeof(regstrs[0])); i++) {
4226 for (j = 0; j < 2; j++) {
4227 snprintf(buff, 0x10,
"%d %s %-4s", i, getsetstr[j], regstrs[i]);
4228 syms[i][j] =
ID2SYM(rb_intern(buff));
4232 valstr = syms[reg][isset];
4235 if (
NIL_P(cv = rb_hash_aref(uh, valstr))) {
4243static void (*ruby_vm_collect_usage_func_insn)(
int insn) = NULL;
4244static void (*ruby_vm_collect_usage_func_operand)(
int insn,
int n,
VALUE op) = NULL;
4245static void (*ruby_vm_collect_usage_func_register)(
int reg,
int isset) = NULL;
4249usage_analysis_insn_start(
VALUE self)
4251 ruby_vm_collect_usage_func_insn = vm_analysis_insn;
4257usage_analysis_operand_start(
VALUE self)
4259 ruby_vm_collect_usage_func_operand = vm_analysis_operand;
4265usage_analysis_register_start(
VALUE self)
4267 ruby_vm_collect_usage_func_register = vm_analysis_register;
4273usage_analysis_insn_stop(
VALUE self)
4275 ruby_vm_collect_usage_func_insn = 0;
4281usage_analysis_operand_stop(
VALUE self)
4283 ruby_vm_collect_usage_func_operand = 0;
4289usage_analysis_register_stop(
VALUE self)
4291 ruby_vm_collect_usage_func_register = 0;
4297usage_analysis_insn_running(
VALUE self)
4299 return RBOOL(ruby_vm_collect_usage_func_insn != 0);
4304usage_analysis_operand_running(
VALUE self)
4306 return RBOOL(ruby_vm_collect_usage_func_operand != 0);
4311usage_analysis_register_running(
VALUE self)
4313 return RBOOL(ruby_vm_collect_usage_func_register != 0);
4317usage_analysis_clear(
VALUE self,
ID usage_hash)
4329usage_analysis_insn_clear(
VALUE self)
4334 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
4335 CONST_ID(bigram_hash,
"USAGE_ANALYSIS_INSN_BIGRAM");
4336 usage_analysis_clear(rb_cRubyVM, usage_hash);
4337 return usage_analysis_clear(rb_cRubyVM, bigram_hash);
4342usage_analysis_operand_clear(
VALUE self)
4346 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
4347 return usage_analysis_clear(self, usage_hash);
4352usage_analysis_register_clear(
VALUE self)
4356 CONST_ID(usage_hash,
"USAGE_ANALYSIS_REGS");
4357 return usage_analysis_clear(self, usage_hash);
4362MAYBE_UNUSED(
static void (*ruby_vm_collect_usage_func_insn)(
int insn)) = 0;
4363MAYBE_UNUSED(
static void (*ruby_vm_collect_usage_func_operand)(
int insn,
int n,
VALUE op)) = 0;
4364MAYBE_UNUSED(
static void (*ruby_vm_collect_usage_func_register)(
int reg,
int isset)) = 0;
4368#if VM_COLLECT_USAGE_DETAILS
4371vm_collect_usage_insn(
int insn)
4373 if (RUBY_DTRACE_INSN_ENABLED()) {
4374 RUBY_DTRACE_INSN(rb_insns_name(insn));
4376 if (ruby_vm_collect_usage_func_insn)
4377 (*ruby_vm_collect_usage_func_insn)(insn);
4385vm_collect_usage_operand(
int insn,
int n,
VALUE op)
4387 if (RUBY_DTRACE_INSN_OPERAND_ENABLED()) {
4390 valstr = rb_insn_operand_intern(GET_EC()->cfp->iseq, insn, n, op, 0, 0, 0, 0);
4392 RUBY_DTRACE_INSN_OPERAND(RSTRING_PTR(valstr), rb_insns_name(insn));
4395 if (ruby_vm_collect_usage_func_operand)
4396 (*ruby_vm_collect_usage_func_operand)(insn, n, op);
4402vm_collect_usage_register(
int reg,
int isset)
4404 if (ruby_vm_collect_usage_func_register)
4405 (*ruby_vm_collect_usage_func_register)(reg, isset);
4412 return &vm_empty_cc;
4416rb_vm_empty_cc_for_super(
void)
4418 return &vm_empty_cc_for_super;
4423#include "vm_call_iseq_optimized.inc"
#define RUBY_ASSERT_MESG(expr, mesg)
Asserts that the expression is truthy.
#define RUBY_ASSERT(expr)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
#define RUBY_ATOMIC_FETCH_ADD(var, val)
Atomically replaces the value pointed by var with the result of addition of val to the old value of v...
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_method_id(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_singleton_method(klass, mid, func, arity)
Defines klass.mid.
#define RUBY_EVENT_END
Encountered an end of a class clause.
#define RUBY_EVENT_B_RETURN
Encountered a next statement.
#define RUBY_EVENT_RETURN
Encountered a return statement.
#define RUBY_EVENT_C_RETURN
Return from a method, written in C.
uint32_t rb_event_flag_t
Represents event(s).
@ RUBY_FL_SHAREABLE
This flag has something to do with Ractor.
VALUE rb_define_class(const char *name, VALUE super)
Defines a top-level class.
VALUE rb_class_new(VALUE super)
Creates a new, anonymous class.
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
void rb_define_alias(VALUE klass, const char *name1, const char *name2)
Defines an alias of a method.
void rb_undef_method(VALUE klass, const char *name)
Defines an undef of a method.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define FL_SINGLETON
Old name of RUBY_FL_SINGLETON.
#define NUM2ULONG
Old name of RB_NUM2ULONG.
#define ALLOCV
Old name of RB_ALLOCV.
#define ALLOC
Old name of RB_ALLOC.
#define xfree
Old name of ruby_xfree.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define T_IMEMO
Old name of RUBY_T_IMEMO.
#define ID2SYM
Old name of RB_ID2SYM.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define ULONG2NUM
Old name of RB_ULONG2NUM.
#define SYM2ID
Old name of RB_SYM2ID.
#define ZALLOC
Old name of RB_ZALLOC.
#define CLASS_OF
Old name of rb_class_of.
#define rb_ary_new4
Old name of rb_ary_new_from_values.
#define SIZET2NUM
Old name of RB_SIZE2NUM.
#define rb_exc_new2
Old name of rb_exc_new_cstr.
#define FIX2INT
Old name of RB_FIX2INT.
#define T_MODULE
Old name of RUBY_T_MODULE.
#define ZALLOC_N
Old name of RB_ZALLOC_N.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define T_ICLASS
Old name of RUBY_T_ICLASS.
#define T_HASH
Old name of RUBY_T_HASH.
#define ALLOC_N
Old name of RB_ALLOC_N.
#define rb_exc_new3
Old name of rb_exc_new_str.
#define ULL2NUM
Old name of RB_ULL2NUM.
#define Qtrue
Old name of RUBY_Qtrue.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define NIL_P
Old name of RB_NIL_P.
#define NUM2ULL
Old name of RB_NUM2ULL.
#define T_CLASS
Old name of RUBY_T_CLASS.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define FL_TEST
Old name of RB_FL_TEST.
#define xcalloc
Old name of ruby_xcalloc.
#define FL_USHIFT
Old name of RUBY_FL_USHIFT.
#define CONST_ID
Old name of RUBY_CONST_ID.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
#define ALLOCV_END
Old name of RB_ALLOCV_END.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
VALUE rb_eLocalJumpError
LocalJumpError exception.
void rb_raise(VALUE exc, const char *fmt,...)
Exception entry point.
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
Checks if the given object is of given kind.
void rb_bug(const char *fmt,...)
Interpreter panic switch.
void rb_iter_break(void)
Breaks from a block.
VALUE rb_eTypeError
TypeError exception.
void rb_iter_break_value(VALUE val)
Identical to rb_iter_break(), except it additionally takes the "value" of this breakage.
VALUE rb_eRuntimeError
RuntimeError exception.
VALUE * rb_ruby_verbose_ptr(void)
This is an implementation detail of ruby_verbose.
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
VALUE rb_eArgError
ArgumentError exception.
VALUE * rb_ruby_debug_ptr(void)
This is an implementation detail of ruby_debug.
VALUE rb_eSysStackError
SystemStackError exception.
VALUE rb_cTime
Time class.
VALUE rb_cArray
Array class.
VALUE rb_cObject
Documented in include/ruby/internal/globals.h.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
VALUE rb_cInteger
Module class.
VALUE rb_cNilClass
NilClass class.
VALUE rb_cBinding
Binding class.
VALUE rb_cRegexp
Regexp class.
VALUE rb_cHash
Hash class.
VALUE rb_cFalseClass
FalseClass class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_cSymbol
Sumbol class.
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_cThread
Thread class.
VALUE rb_obj_freeze(VALUE obj)
Just calls rb_obj_freeze_inline() inside.
VALUE rb_cFloat
Float class.
VALUE rb_cProc
Proc class.
VALUE rb_cTrueClass
TrueClass class.
VALUE rb_cString
String class.
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
Defines RBIMPL_HAS_BUILTIN.
void rb_undef(VALUE mod, ID mid)
Inserts a method entry that hides previous method definition of the given name.
VALUE rb_backref_get(void)
Queries the last match, or Regexp.last_match, or the $~.
void rb_lastline_set(VALUE str)
Updates $_.
VALUE rb_lastline_get(void)
Queries the last line, or the $_.
void rb_backref_set(VALUE md)
Updates $~.
VALUE rb_block_proc(void)
Constructs a Proc object from implicitly passed components.
VALUE rb_block_lambda(void)
Identical to rb_proc_new(), except it returns a lambda.
VALUE rb_binding_new(void)
Snapshots the current execution context and turn it into an instance of rb_cBinding.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
VALUE rb_str_dup(VALUE str)
Duplicates a string.
#define rb_str_cat_cstr(buf, str)
Identical to rb_str_cat(), except it assumes the passed pointer is a pointer to a C string.
VALUE rb_const_get(VALUE space, ID name)
Identical to rb_const_defined(), except it returns the actual defined value.
VALUE rb_attr_get(VALUE obj, ID name)
Identical to rb_ivar_get()
void rb_set_class_path(VALUE klass, VALUE space, const char *name)
Names a class.
void rb_alias_variable(ID dst, ID src)
Aliases a global variable.
VALUE rb_class_path(VALUE mod)
Identical to rb_mod_name(), except it returns #<Class: ...> style inspection for anonymous modules.
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
const char * rb_sourcefile(void)
Resembles __FILE__.
void rb_alias(VALUE klass, ID dst, ID src)
Resembles alias.
int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
Resembles __method__.
int rb_sourceline(void)
Resembles __LINE__.
VALUE rb_sym2str(VALUE id)
Identical to rb_id2str(), except it takes an instance of rb_cSymbol rather than an ID.
const char * rb_id2name(ID id)
Retrieves the name mapped to the given id.
void rb_define_global_const(const char *name, VALUE val)
Identical to rb_define_const(), except it defines that of "global", i.e.
void rb_define_const(VALUE klass, const char *name, VALUE val)
Defines a Ruby level constant under a namespace.
VALUE rb_iv_set(VALUE obj, const char *name, VALUE val)
Assigns to an instance variable.
VALUE rb_ractor_make_shareable_copy(VALUE obj)
Identical to rb_ractor_make_shareable(), except it returns a (deep) copy of the passed one instead of...
static bool rb_ractor_shareable_p(VALUE obj)
Queries if multiple Ractors can share the passed object or not.
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
VALUE rb_ractor_make_shareable(VALUE obj)
Destructively transforms the passed object so that multiple Ractors can share it.
void ruby_vm_at_exit(void(*func)(ruby_vm_t *))
ruby_vm_at_exit registers a function func to be invoked when a VM passed away.
int ruby_vm_destruct(ruby_vm_t *vm)
Destructs the passed VM.
VALUE rb_f_sprintf(int argc, const VALUE *argv)
Identical to rb_str_format(), except how the arguments are arranged.
VALUE rb_sprintf(const char *fmt,...)
Ruby's extended sprintf(3).
VALUE rb_str_catf(VALUE dst, const char *fmt,...)
Identical to rb_sprintf(), except it renders the output to the specified object rather than creating ...
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define MEMZERO(p, type, n)
Handy macro to erase a region of memory.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
VALUE type(ANYARGS)
ANYARGS-ed function type.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY_AREF(a, i)
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
#define RBASIC(obj)
Convenient casting macro.
#define RHASH_EMPTY_P(h)
Checks if the hash is empty.
#define StringValuePtr(v)
Identical to StringValue, except it returns a char*.
#define RTYPEDDATA_DATA(v)
Convenient getter macro.
#define TypedData_Wrap_Struct(klass, data_type, sval)
Converts sval, a pointer to your struct, into a Ruby object.
#define TypedData_Make_Struct(klass, type, data_type, sval)
Identical to TypedData_Wrap_Struct, except it allocates a new data region internally instead of takin...
#define RB_NO_KEYWORDS
Do not pass keywords.
static VALUE rb_special_const_p(VALUE obj)
Identical to RB_SPECIAL_CONST_P, except it returns a VALUE.
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
void rb_native_cond_initialize(rb_nativethread_cond_t *cond)
Fills the passed condition variable with an initial value.
void rb_native_mutex_initialize(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_initialize.
void rb_native_mutex_destroy(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_destroy.
uintptr_t VALUE
Type that represents a Ruby object.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
ruby_value_type
C-level type of an object.