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"
35 #include "vm_callinfo.h"
38 #include "vm_insnhelper.h"
39 #include "ractor_core.h"
47 #include "probes.dmyh"
49 #include "probes_helper.h"
51 VALUE rb_str_concat_literals(
size_t,
const VALUE*);
64 PUREFUNC(
static inline const VALUE *VM_EP_LEP(
const VALUE *));
65 static inline const VALUE *
66 VM_EP_LEP(
const VALUE *ep)
68 while (!VM_ENV_LOCAL_P(ep)) {
69 ep = VM_ENV_PREV_EP(ep);
87 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
95 rb_vm_ep_local_ep(
const VALUE *ep)
101 static inline const VALUE *
104 return VM_EP_LEP(cfp->ep);
107 static inline const VALUE *
110 return VM_ENV_PREV_EP(cfp->ep);
117 const VALUE *ep = VM_CF_LEP(cfp);
118 return VM_ENV_BLOCK_HANDLER(ep);
124 return VM_FRAME_CFRAME_KW_P(cfp);
130 return VM_CF_BLOCK_HANDLER(cfp);
133 #if VM_CHECK_MODE > 0
137 const VALUE *start = ec->vm_stack;
138 const VALUE *end = (
VALUE *)ec->vm_stack + ec->vm_stack_size;
139 VM_ASSERT(start != NULL);
141 if (start <= (
VALUE *)cfp && (
VALUE *)cfp < end) {
152 const VALUE *start = ec->vm_stack;
154 VM_ASSERT(start != NULL);
156 if (start <= ep && ep < end) {
167 if (VM_EP_IN_HEAP_P(ec, ep)) {
168 VALUE envval = ep[VM_ENV_DATA_INDEX_ENV];
173 VM_ASSERT(vm_assert_env(envval));
174 VM_ASSERT(VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED));
175 VM_ASSERT(env->ep == ep);
185 rb_vm_ep_in_heap_p(
const VALUE *ep)
188 if (ec->vm_stack == NULL)
return TRUE;
189 return vm_ep_in_heap_p_(ec, ep);
196 VM_ASSERT(!VM_CFP_IN_HEAP_P(GET_EC(), cfp));
204 VM_ASSERT(!VM_CFP_IN_HEAP_P(GET_EC(), cfp));
213 return VM_TAGGED_PTR_REF(block_handler, 0x03) == captured;
219 VALUE block_handler = ec->passed_block_handler;
220 ec->passed_block_handler = VM_BLOCK_HANDLER_NONE;
221 vm_block_handler_verify(block_handler);
222 return block_handler;
226 vm_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)
229 int omod_shared = FALSE;
238 scope_visi.visi.method_visi = visi;
239 scope_visi.visi.module_func = module_func;
242 if (prev_cref != NULL && prev_cref != (
void *)1 ) {
243 refinements = CREF_REFINEMENTS(prev_cref);
245 if (!
NIL_P(refinements)) {
247 CREF_OMOD_SHARED_SET(prev_cref);
251 VM_ASSERT(singleton || klass);
253 cref = (
rb_cref_t *)rb_imemo_new(imemo_cref, klass, (
VALUE)(use_prev_prev ? CREF_NEXT(prev_cref) : prev_cref), scope_visi.value, refinements);
255 if (pushed_by_eval) CREF_PUSHED_BY_EVAL_SET(cref);
256 if (omod_shared) CREF_OMOD_SHARED_SET(cref);
257 if (singleton) CREF_SINGLETON_SET(cref);
263 vm_cref_new(
VALUE klass, rb_method_visibility_t visi,
int module_func,
rb_cref_t *prev_cref,
int pushed_by_eval,
int singleton)
265 return vm_cref_new0(klass, visi, module_func, prev_cref, pushed_by_eval, FALSE, singleton);
269 vm_cref_new_use_prev(
VALUE klass, rb_method_visibility_t visi,
int module_func,
rb_cref_t *prev_cref,
int pushed_by_eval)
271 return vm_cref_new0(klass, visi, module_func, prev_cref, pushed_by_eval, TRUE, FALSE);
277 return SYMBOL_P(key) ? ST_DELETE : ST_CONTINUE;
284 rb_cref_t *next_cref = CREF_NEXT(cref), *new_cref;
285 int pushed_by_eval = CREF_PUSHED_BY_EVAL(cref);
286 int singleton = CREF_SINGLETON(cref);
288 new_cref = vm_cref_new(cref->klass_or_self, visi->method_visi, visi->module_func, next_cref, pushed_by_eval, singleton);
290 if (!
NIL_P(CREF_REFINEMENTS(cref))) {
293 CREF_REFINEMENTS_SET(new_cref, ref);
294 CREF_OMOD_SHARED_UNSET(new_cref);
302 rb_vm_cref_dup_without_refinements(
const rb_cref_t *cref)
305 rb_cref_t *next_cref = CREF_NEXT(cref), *new_cref;
306 int pushed_by_eval = CREF_PUSHED_BY_EVAL(cref);
307 int singleton = CREF_SINGLETON(cref);
309 new_cref = vm_cref_new(cref->klass_or_self, visi->method_visi, visi->module_func, next_cref, pushed_by_eval, singleton);
311 if (!
NIL_P(CREF_REFINEMENTS(cref))) {
312 CREF_REFINEMENTS_SET(new_cref,
Qnil);
313 CREF_OMOD_SHARED_UNSET(new_cref);
322 rb_cref_t *cref = vm_cref_new(rb_cObject, METHOD_VISI_PRIVATE , FALSE, NULL, FALSE, FALSE);
323 VALUE top_wrapper = rb_ec_thread_ptr(ec)->top_wrapper;
326 cref = vm_cref_new(top_wrapper, METHOD_VISI_PRIVATE, FALSE, cref, FALSE, FALSE);
333 rb_vm_cref_new_toplevel(
void)
335 return vm_cref_new_toplevel(GET_EC());
339 vm_cref_dump(
const char *mesg,
const rb_cref_t *cref)
341 ruby_debug_printf(
"vm_cref_dump: %s (%p)\n", mesg, (
void *)cref);
345 cref = CREF_NEXT(cref);
352 *((
const VALUE **)&dst->as.captured.ep) = ep;
360 RB_OBJ_WRITE(bindval, &bind->block.as.captured.code.iseq, env->iseq);
361 rb_vm_block_ep_update(bindval, &bind->block, env->ep);
364 #if VM_COLLECT_USAGE_DETAILS
365 static void vm_collect_usage_operand(
int insn,
int n,
VALUE op);
366 static void vm_collect_usage_insn(
int insn);
367 static void vm_collect_usage_register(
int reg,
int isset);
372 int argc,
const VALUE *argv,
int kw_splat,
VALUE block_handler,
376 #include "vm_insnhelper.c"
382 #include "vm_method.c"
390 rb_next_class_serial(
void)
392 rb_serial_t class_serial = NEXT_CLASS_SERIAL();
398 VALUE rb_mRubyVMFrozenCore;
399 VALUE rb_block_param_proxy;
401 #define ruby_vm_redefined_flag GET_VM()->redefined_flag
402 VALUE ruby_vm_const_missing_count = 0;
403 rb_vm_t *ruby_current_vm_ptr = NULL;
405 bool ruby_vm_keep_script_lines;
407 #ifdef RB_THREAD_LOCAL_SPECIFIER
414 return ruby_current_ec;
419 ruby_current_ec = ec;
424 native_tls_key_t ruby_current_ec_key;
429 unsigned int ruby_vm_event_local_num;
431 rb_serial_t ruby_vm_global_constant_state = 1;
432 rb_serial_t ruby_vm_class_serial = 1;
433 rb_serial_t ruby_vm_global_cvar_state = 1;
436 .flags =
T_IMEMO | (imemo_callcache <<
FL_USHIFT) | VM_CALLCACHE_UNMARKABLE,
439 .call_ = vm_call_general,
445 static const struct rb_callcache vm_empty_cc_for_super = {
446 .flags =
T_IMEMO | (imemo_callcache <<
FL_USHIFT) | VM_CALLCACHE_UNMARKABLE,
449 .call_ = vm_call_super_method,
455 static void thread_free(
void *ptr);
458 rb_vm_inc_const_missing_count(
void)
460 ruby_vm_const_missing_count +=1;
463 MJIT_FUNC_EXPORTED
int
469 if (!ec) ec = GET_EC();
470 if (!rb_ec_frame_method_id_and_class(ec, &
id, 0, &klass) || !klass)
474 klass =
RBASIC(klass)->klass;
478 if (
NIL_P(klass))
return FALSE;
483 const char *classname, *filename;
485 if (methodname && (filename = rb_source_location_cstr(&args->line_no)) != 0) {
487 classname =
"<unknown>";
488 args->classname = classname;
489 args->methodname = methodname;
490 args->filename = filename;
523 static VALUE sym_global_constant_state, sym_class_serial, sym_global_cvar_state;
540 if (sym_global_constant_state == 0) {
541 #define S(s) sym_##s = ID2SYM(rb_intern_const(#s))
542 S(global_constant_state);
544 S(global_cvar_state);
548 #define SET(name, attr) \
549 if (key == sym_##name) \
550 return SERIALT2NUM(attr); \
551 else if (hash != Qnil) \
552 rb_hash_aset(hash, sym_##name, SERIALT2NUM(attr));
554 SET(global_constant_state, ruby_vm_global_constant_state);
555 SET(class_serial, ruby_vm_class_serial);
556 SET(global_cvar_state, ruby_vm_global_cvar_state);
571 if (iseq->body->type != ISEQ_TYPE_TOP) {
576 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_TOP | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH, rb_ec_thread_ptr(ec)->top_self,
577 VM_BLOCK_HANDLER_NONE,
578 (
VALUE)vm_cref_new_toplevel(ec),
579 iseq->body->iseq_encoded, ec->cfp->sp,
580 iseq->body->local_table_size, iseq->body->stack_max);
586 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_EVAL | VM_FRAME_FLAG_FINISH,
587 vm_block_self(base_block), VM_GUARDED_PREV_EP(vm_block_ep(base_block)),
589 iseq->body->iseq_encoded,
590 ec->cfp->sp, iseq->body->local_table_size,
591 iseq->body->stack_max);
600 GetBindingPtr(toplevel_binding, bind);
603 vm_set_eval_stack(ec, iseq, 0, &bind->block);
606 if (iseq->body->local_table_size > 0) {
607 vm_bind_update_env(toplevel_binding, bind, vm_make_env_object(ec, ec->cfp));
614 while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
618 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
626 while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
627 if (VM_FRAME_RUBYFRAME_P(cfp)) {
630 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
640 if (VM_FRAME_RUBYFRAME_P(cfp)) {
644 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
646 while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
647 if (VM_FRAME_RUBYFRAME_P(cfp)) {
651 if (VM_ENV_FLAGS(cfp->ep, VM_FRAME_FLAG_PASSED) == FALSE) {
654 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
660 rb_vm_pop_cfunc_frame(
void)
667 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
668 vm_pop_frame(ec, cfp, cfp->ep);
677 while (ec->cfp != cfp) {
679 printf(
"skipped frame: %s\n", vm_frametype_name(ec->cfp));
681 if (VM_FRAME_TYPE(ec->cfp) != VM_FRAME_MAGIC_CFUNC) {
685 rb_vm_pop_cfunc_frame();
698 nl->next = vm->at_exit;
703 ruby_vm_run_at_exit_hooks(
rb_vm_t *vm)
709 rb_vm_at_exit_func *func = l->func;
723 fputs(
"---\n", stderr);
724 ruby_debug_printf(
"envptr: %p\n", (
void *)&env->ep[0]);
725 ruby_debug_printf(
"envval: %10p ", (
void *)env->ep[1]);
727 ruby_debug_printf(
"ep: %10p\n", (
void *)env->ep);
728 if (rb_vm_env_prev_env(env)) {
729 fputs(
">>\n", stderr);
730 check_env_value(rb_vm_env_prev_env(env));
731 fputs(
"<<\n", stderr);
737 check_env_value(
const rb_env_t *env)
739 if (check_env(env)) {
749 switch (vm_block_handler_type(block_handler)) {
750 case block_handler_type_ifunc:
751 case block_handler_type_iseq:
752 return rb_vm_make_proc(ec, VM_BH_TO_CAPT_BLOCK(block_handler),
rb_cProc);
754 case block_handler_type_symbol:
755 case block_handler_type_proc:
756 return block_handler;
758 VM_UNREACHABLE(vm_block_handler_escape);
765 const VALUE *
const ep = cfp->ep;
768 VALUE *env_body, *env_ep;
769 int local_size, env_size;
771 if (VM_ENV_ESCAPED_P(ep)) {
772 return VM_ENV_ENVVAL(ep);
775 if (!VM_ENV_LOCAL_P(ep)) {
776 const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
777 if (!VM_ENV_ESCAPED_P(prev_ep)) {
780 while (prev_cfp->ep != prev_ep) {
781 prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(prev_cfp);
782 VM_ASSERT(prev_cfp->ep != NULL);
785 vm_make_env_each(ec, prev_cfp);
786 VM_FORCE_WRITE_SPECIAL_CONST(&ep[VM_ENV_DATA_INDEX_SPECVAL], VM_GUARDED_PREV_EP(prev_cfp->ep));
790 VALUE block_handler = VM_ENV_BLOCK_HANDLER(ep);
792 if (block_handler != VM_BLOCK_HANDLER_NONE) {
793 VALUE blockprocval = vm_block_handler_escape(ec, block_handler);
794 VM_STACK_ENV_WRITE(ep, VM_ENV_DATA_INDEX_SPECVAL, blockprocval);
798 if (!VM_FRAME_RUBYFRAME_P(cfp)) {
799 local_size = VM_ENV_DATA_SIZE;
802 local_size = cfp->iseq->body->local_table_size + VM_ENV_DATA_SIZE;
817 env_size = local_size +
820 MEMCPY(env_body, ep - (local_size - 1 ),
VALUE, local_size);
823 for (i = 0; i < local_size; i++) {
824 if (VM_FRAME_RUBYFRAME_P(cfp)) {
826 ep[-local_size + i] = 0;
831 env_iseq = VM_FRAME_RUBYFRAME_P(cfp) ? cfp->iseq : NULL;
832 env_ep = &env_body[local_size - 1 ];
834 env = vm_env_new(env_ep, env_body, env_size, env_iseq);
837 VM_ENV_FLAGS_SET(env_ep, VM_ENV_FLAG_ESCAPED | VM_ENV_FLAG_WB_REQUIRED);
838 VM_STACK_ENV_WRITE(ep, 0, (
VALUE)env);
845 VALUE envval = vm_make_env_each(ec, cfp);
848 check_env_value((
const rb_env_t *)envval);
858 while ((cfp = rb_vm_get_binding_creatable_next_cfp(ec, cfp)) != 0) {
859 vm_make_env_object(ec, cfp);
860 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
865 rb_vm_env_prev_env(
const rb_env_t *env)
867 const VALUE *ep = env->ep;
869 if (VM_ENV_LOCAL_P(ep)) {
873 const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
874 return VM_ENV_ENVVAL_PTR(prev_ep);
883 for (i = 0; i < iseq->body->local_table_size; i++) {
884 local_var_list_add(vars, iseq->body->local_table[i]);
893 if (VM_ENV_FLAGS(env->ep, VM_ENV_FLAG_ISOLATED))
break;
894 collect_local_variables_in_iseq(env->iseq, vars);
895 }
while ((env = rb_vm_env_prev_env(env)) != NULL);
901 if (VM_ENV_ESCAPED_P(ep)) {
902 collect_local_variables_in_env(VM_ENV_ENVVAL_PTR(ep), vars);
911 rb_vm_env_local_variables(
const rb_env_t *env)
914 local_var_list_init(&vars);
915 collect_local_variables_in_env(env, &vars);
916 return local_var_list_finish(&vars);
920 rb_iseq_local_variables(
const rb_iseq_t *iseq)
923 local_var_list_init(&vars);
924 while (collect_local_variables_in_iseq(iseq, &vars)) {
925 iseq = iseq->body->parent_iseq;
927 return local_var_list_finish(&vars);
933 vm_proc_create_from_captured(
VALUE klass,
935 enum rb_block_type block_type,
936 int8_t is_from_method, int8_t is_lambda)
938 VALUE procval = rb_proc_alloc(klass);
941 VM_ASSERT(VM_EP_IN_HEAP_P(GET_EC(), captured->ep));
944 RB_OBJ_WRITE(procval, &proc->block.as.captured.code.val, captured->code.val);
945 RB_OBJ_WRITE(procval, &proc->block.as.captured.self, captured->self);
946 rb_vm_block_ep_update(procval, &proc->block, captured->ep);
948 vm_block_type_set(&proc->block, block_type);
949 proc->is_from_method = is_from_method;
950 proc->is_lambda = is_lambda;
959 switch (vm_block_type(src)) {
960 case block_type_iseq:
961 case block_type_ifunc:
962 RB_OBJ_WRITE(obj, &dst->as.captured.self, src->as.captured.self);
963 RB_OBJ_WRITE(obj, &dst->as.captured.code.val, src->as.captured.code.val);
964 rb_vm_block_ep_update(obj, dst, src->as.captured.ep);
966 case block_type_symbol:
969 case block_type_proc:
976 proc_create(
VALUE klass,
const struct rb_block *block, int8_t is_from_method, int8_t is_lambda)
978 VALUE procval = rb_proc_alloc(klass);
981 VM_ASSERT(VM_EP_IN_HEAP_P(GET_EC(), vm_block_ep(block)));
982 rb_vm_block_copy(procval, &proc->block, block);
983 vm_block_type_set(&proc->block, block->type);
984 proc->is_from_method = is_from_method;
985 proc->is_lambda = is_lambda;
991 rb_proc_dup(
VALUE self)
996 GetProcPtr(
self, src);
997 procval = proc_create(
rb_cProc, &src->block, src->is_from_method, src->is_lambda);
1013 if (SIZEOF_VOIDP > SIZEOF_LONG)
1022 if (SIZEOF_VOIDP > SIZEOF_LONG)
1028 static enum rb_id_table_iterator_result
1029 collect_outer_variable_names(
ID id,
VALUE val,
void *ptr)
1038 if (data->isolate ||
1043 store = &data->read_only;
1048 return ID_TABLE_CONTINUE;
1052 env_copy(
const VALUE *src_ep,
VALUE read_only_variables)
1055 VM_ASSERT(src_env->ep == src_ep);
1058 VALUE *ep = &env_body[src_env->env_size - 2];
1061 if (read_only_variables) {
1062 for (
int i=
RARRAY_LENINT(read_only_variables)-1; i>=0; i--) {
1065 for (
unsigned int j=0; j<src_env->iseq->body->local_table_size; j++) {
1066 if (
id == src_env->iseq->body->local_table[j]) {
1067 VALUE v = src_env->env[j];
1070 VALUE msg =
rb_sprintf(
"can not make shareable Proc because it can refer"
1071 " unshareable object %+" PRIsVALUE
" from ", v);
1073 rb_str_catf(msg,
"variable `%" PRIsVALUE
"'", name);
1086 ep[VM_ENV_DATA_INDEX_ME_CREF] = src_ep[VM_ENV_DATA_INDEX_ME_CREF];
1087 ep[VM_ENV_DATA_INDEX_FLAGS] = src_ep[VM_ENV_DATA_INDEX_FLAGS] | VM_ENV_FLAG_ISOLATED;
1089 if (!VM_ENV_LOCAL_P(src_ep)) {
1090 const VALUE *prev_ep = VM_ENV_PREV_EP(src_env->ep);
1091 const rb_env_t *new_prev_env = env_copy(prev_ep, read_only_variables);
1092 prev_env = (
VALUE)new_prev_env;
1093 ep[VM_ENV_DATA_INDEX_SPECVAL] = VM_GUARDED_PREV_EP(new_prev_env->ep);
1096 ep[VM_ENV_DATA_INDEX_SPECVAL] = VM_BLOCK_HANDLER_NONE;
1099 const rb_env_t *copied_env = vm_env_new(ep, env_body, src_env->env_size, src_env->iseq);
1108 const rb_env_t *env = env_copy(captured->ep, read_only_variables);
1109 *((
const VALUE **)&proc->block.as.captured.ep) = env->ep;
1114 proc_shared_outer_variables(
struct rb_id_table *outer_variables,
bool isolate,
const char *message)
1122 rb_id_table_foreach(outer_variables, collect_outer_variable_names, (
void *)&data);
1124 if (data.ary !=
Qfalse) {
1125 VALUE str =
rb_sprintf(
"can not %s because it accesses outer variables", message);
1126 VALUE ary = data.ary;
1127 const char *sep =
" (";
1130 if (!name)
continue;
1139 else if (data.yield) {
1143 return data.read_only;
1147 rb_proc_isolate_bang(
VALUE self)
1149 const rb_iseq_t *iseq = vm_proc_iseq(
self);
1155 if (iseq->body->outer_variables) {
1156 proc_shared_outer_variables(iseq->body->outer_variables,
true,
"isolate a Proc");
1159 proc_isolate_env(
self, proc,
Qfalse);
1160 proc->is_isolated = TRUE;
1168 rb_proc_isolate(
VALUE self)
1170 VALUE dst = rb_proc_dup(
self);
1171 rb_proc_isolate_bang(dst);
1176 rb_proc_ractor_make_shareable(
VALUE self)
1178 const rb_iseq_t *iseq = vm_proc_iseq(
self);
1186 "Proc's self is not shareable: %" PRIsVALUE,
1192 if (iseq->body->outer_variables) {
1193 read_only_variables =
1194 proc_shared_outer_variables(iseq->body->outer_variables,
false,
"make a Proc shareable");
1197 proc_isolate_env(
self, proc, read_only_variables);
1198 proc->is_isolated = TRUE;
1205 MJIT_FUNC_EXPORTED
VALUE
1210 if (!VM_ENV_ESCAPED_P(captured->ep)) {
1212 vm_make_env_object(ec, cfp);
1214 VM_ASSERT(VM_EP_IN_HEAP_P(ec, captured->ep));
1215 VM_ASSERT(imemo_type_p(captured->code.val, imemo_iseq) ||
1216 imemo_type_p(captured->code.val, imemo_ifunc));
1218 procval = vm_proc_create_from_captured(klass, captured,
1219 imemo_type(captured->code.val) == imemo_iseq ? block_type_iseq : block_type_ifunc, FALSE, is_lambda);
1230 VALUE bindval, envval;
1233 if (cfp == 0 || ruby_level_cfp == 0) {
1238 envval = vm_make_env_object(ec, cfp);
1239 if (cfp == ruby_level_cfp) {
1242 cfp = rb_vm_get_binding_creatable_next_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
1246 GetBindingPtr(bindval, bind);
1247 vm_bind_update_env(bindval, bind, envval);
1248 RB_OBJ_WRITE(bindval, &bind->block.as.captured.self, cfp->self);
1249 RB_OBJ_WRITE(bindval, &bind->block.as.captured.code.iseq, cfp->iseq);
1250 RB_OBJ_WRITE(bindval, &bind->pathobj, ruby_level_cfp->iseq->body->location.pathobj);
1251 bind->first_lineno = rb_vm_get_sourceline(ruby_level_cfp);
1257 rb_binding_add_dynavars(
VALUE bindval,
rb_binding_t *bind,
int dyncount,
const ID *dynvars)
1259 VALUE envval, pathobj = bind->pathobj;
1260 VALUE path = pathobj_path(pathobj);
1261 VALUE realpath = pathobj_realpath(pathobj);
1269 if (dyncount < 0)
return 0;
1271 base_block = &bind->block;
1272 base_iseq = vm_block_iseq(base_block);
1276 dyns->size = dyncount;
1277 MEMCPY(dyns->ids, dynvars,
ID, dyncount);
1279 rb_node_init(&tmp_node, NODE_SCOPE, (
VALUE)dyns, 0, 0);
1280 ast.root = &tmp_node;
1281 ast.compile_option = 0;
1282 ast.script_lines =
INT2FIX(-1);
1285 iseq = rb_iseq_new(&ast, base_iseq->body->location.label, path, realpath, base_iseq, ISEQ_TYPE_EVAL);
1288 VALUE tempstr = rb_fstring_lit(
"<temp>");
1289 iseq = rb_iseq_new_top(&ast, tempstr, tempstr, tempstr, NULL);
1291 tmp_node.nd_tbl = 0;
1294 vm_set_eval_stack(ec, iseq, 0, base_block);
1295 vm_bind_update_env(bindval, bind, envval = vm_make_env_object(ec, ec->cfp));
1296 rb_vm_pop_frame(ec);
1307 int arg_size = iseq->body->
param.size;
1309 vm_push_frame(ec, iseq,
type | VM_FRAME_FLAG_FINISH,
self,
1310 VM_GUARDED_PREV_EP(captured->ep),
1312 iseq->body->iseq_encoded + opt_pc,
1313 ec->cfp->sp + arg_size,
1314 iseq->body->local_table_size - arg_size,
1315 iseq->body->stack_max);
1316 return vm_exec(ec,
true);
1323 int arg_size = iseq->body->
param.size;
1326 VM_ASSERT(me->def->type == VM_METHOD_TYPE_BMETHOD);
1328 vm_push_frame(ec, iseq,
type | VM_FRAME_FLAG_BMETHOD,
self,
1329 VM_GUARDED_PREV_EP(captured->ep),
1331 iseq->body->iseq_encoded + opt_pc,
1332 ec->cfp->sp + arg_size,
1333 iseq->body->local_table_size - arg_size,
1334 iseq->body->stack_max);
1336 VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);
1337 ret = vm_exec(ec,
true);
1342 ALWAYS_INLINE(
static VALUE
1344 VALUE self,
int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler,
1349 VALUE self,
int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler,
1352 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
1354 VALUE type = VM_FRAME_MAGIC_BLOCK | (is_lambda ? VM_FRAME_FLAG_LAMBDA : 0);
1356 VALUE *sp = cfp->sp;
1360 CHECK_VM_STACK_OVERFLOW(cfp, argc);
1361 vm_check_canary(ec, sp);
1362 cfp->sp = sp + argc;
1363 for (i=0; i<argc; i++) {
1367 opt_pc = vm_yield_setup_args(ec, iseq, argc, sp, kw_splat, passed_block_handler,
1368 (is_lambda ? arg_setup_method : arg_setup_block));
1372 return invoke_block(ec, iseq,
self, captured, cref,
type, opt_pc);
1375 return invoke_bmethod(ec, iseq,
self, captured, me,
type, opt_pc);
1381 int argc,
const VALUE *argv,
1383 int is_lambda,
int force_blockarg)
1386 switch (vm_block_handler_type(block_handler)) {
1387 case block_handler_type_iseq:
1390 return invoke_iseq_block_from_c(ec, captured, captured->self,
1391 argc, argv, kw_splat, passed_block_handler,
1392 cref, is_lambda, NULL);
1394 case block_handler_type_ifunc:
1395 return vm_yield_with_cfunc(ec, VM_BH_TO_IFUNC_BLOCK(block_handler),
1396 VM_BH_TO_IFUNC_BLOCK(block_handler)->
self,
1397 argc, argv, kw_splat, passed_block_handler, NULL);
1398 case block_handler_type_symbol:
1399 return vm_yield_with_symbol(ec, VM_BH_TO_SYMBOL(block_handler),
1400 argc, argv, kw_splat, passed_block_handler);
1401 case block_handler_type_proc:
1402 if (force_blockarg == FALSE) {
1403 is_lambda = block_proc_is_lambda(VM_BH_TO_PROC(block_handler));
1405 block_handler = vm_proc_to_block_handler(VM_BH_TO_PROC(block_handler));
1408 VM_UNREACHABLE(invoke_block_from_c_splattable);
1415 VALUE block_handler = VM_CF_BLOCK_HANDLER(ec->cfp);
1416 vm_block_handler_verify(block_handler);
1417 if (UNLIKELY(block_handler == VM_BLOCK_HANDLER_NONE)) {
1418 rb_vm_localjump_error(
"no block given",
Qnil, 0);
1421 return block_handler;
1427 return invoke_block_from_c_bh(ec, check_block_handler(ec),
1428 argc, argv, kw_splat, VM_BLOCK_HANDLER_NONE,
1429 cref, is_lambda, FALSE);
1435 return vm_yield_with_cref(ec, argc, argv, kw_splat, NULL, FALSE);
1441 return invoke_block_from_c_bh(ec, check_block_handler(ec),
1442 argc, argv, kw_splat, block_handler,
1443 NULL, FALSE, FALSE);
1449 return invoke_block_from_c_bh(ec, check_block_handler(ec), 1, &args,
1453 ALWAYS_INLINE(
static VALUE
1456 int kw_splat,
VALUE passed_block_handler,
int is_lambda,
1462 int kw_splat,
VALUE passed_block_handler,
int is_lambda,
1465 const struct rb_block *block = &proc->block;
1468 switch (vm_block_type(block)) {
1469 case block_type_iseq:
1470 return invoke_iseq_block_from_c(ec, &block->as.captured,
self, argc, argv, kw_splat, passed_block_handler, NULL, is_lambda, me);
1471 case block_type_ifunc:
1472 if (kw_splat == 1) {
1473 VALUE keyword_hash = argv[argc-1];
1475 keyword_hash = rb_to_hash_type(keyword_hash);
1484 return vm_yield_with_cfunc(ec, &block->as.captured,
self, argc, argv, kw_splat, passed_block_handler, me);
1485 case block_type_symbol:
1486 return vm_yield_with_symbol(ec, block->as.symbol, argc, argv, kw_splat, passed_block_handler);
1487 case block_type_proc:
1488 is_lambda = block_proc_is_lambda(block->as.proc);
1489 block = vm_proc_block(block->as.proc);
1492 VM_UNREACHABLE(invoke_block_from_c_proc);
1498 int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler)
1500 return invoke_block_from_c_proc(ec, proc,
self, argc, argv, kw_splat, passed_block_handler, proc->is_lambda, NULL);
1503 MJIT_FUNC_EXPORTED
VALUE
1507 return invoke_block_from_c_proc(ec, proc,
self, argc, argv, kw_splat, block_handler, TRUE, me);
1510 MJIT_FUNC_EXPORTED
VALUE
1512 int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler)
1514 VALUE self = vm_block_self(&proc->block);
1515 vm_block_handler_verify(passed_block_handler);
1517 if (proc->is_from_method) {
1518 return rb_vm_invoke_bmethod(ec, proc,
self, argc, argv, kw_splat, passed_block_handler, NULL);
1521 return vm_invoke_proc(ec, proc,
self, argc, argv, kw_splat, passed_block_handler);
1527 int argc,
const VALUE *argv,
int kw_splat,
VALUE passed_block_handler)
1529 vm_block_handler_verify(passed_block_handler);
1531 if (proc->is_from_method) {
1532 return rb_vm_invoke_bmethod(ec, proc,
self, argc, argv, kw_splat, passed_block_handler, NULL);
1535 return vm_invoke_proc(ec, proc,
self, argc, argv, kw_splat, passed_block_handler);
1544 while (cfp->pc == 0) {
1545 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
1546 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
1556 cfp = vm_normal_frame(ec, cfp);
1557 return lep_svar_get(ec, cfp ? VM_CF_LEP(cfp) : 0, key);
1563 cfp = vm_normal_frame(ec, cfp);
1564 lep_svar_set(ec, cfp ? VM_CF_LEP(cfp) : 0, key, val);
1570 return vm_cfp_svar_get(ec, ec->cfp, key);
1576 vm_cfp_svar_set(ec, ec->cfp, key, val);
1582 return vm_svar_get(GET_EC(), VM_SVAR_BACKREF);
1588 vm_svar_set(GET_EC(), VM_SVAR_BACKREF, val);
1594 return vm_svar_get(GET_EC(), VM_SVAR_LASTLINE);
1600 vm_svar_set(GET_EC(), VM_SVAR_LASTLINE, val);
1626 return rb_vm_get_sourceline(cfp);
1634 rb_source_location(
int *pline)
1639 if (cfp && VM_FRAME_RUBYFRAME_P(cfp)) {
1640 if (pline) *pline = rb_vm_get_sourceline(cfp);
1641 return rb_iseq_path(cfp->iseq);
1644 if (pline) *pline = 0;
1649 MJIT_FUNC_EXPORTED
const char *
1650 rb_source_location_cstr(
int *pline)
1652 VALUE path = rb_source_location(pline);
1653 if (
NIL_P(path))
return NULL;
1661 return vm_ec_cref(ec);
1665 rb_vm_cref_replace_with_duplicated_cref(
void)
1669 rb_cref_t *cref = vm_cref_replace_with_duplicated_cref(cfp->ep);
1675 rb_vm_cref_in_context(
VALUE self,
VALUE cbase)
1680 if (!cfp || cfp->self !=
self)
return NULL;
1681 if (!vm_env_cref_by_cref(cfp->ep))
return NULL;
1682 cref = vm_get_cref(cfp->ep);
1683 if (CREF_CLASS(cref) != cbase)
return NULL;
1692 dp(CREF_CLASS(cref));
1693 printf(
"%ld\n", CREF_VISI(cref));
1694 cref = CREF_NEXT(cref);
1708 return vm_get_cbase(cfp->ep);
1714 make_localjump_error(
const char *mesg,
VALUE value,
int reason)
1745 MJIT_FUNC_EXPORTED
void
1746 rb_vm_localjump_error(
const char *mesg,
VALUE value,
int reason)
1748 VALUE exc = make_localjump_error(mesg, value, reason);
1753 rb_vm_make_jump_tag_but_local_jump(
int state,
VALUE val)
1759 mesg =
"unexpected return";
1762 mesg =
"unexpected break";
1765 mesg =
"unexpected next";
1768 mesg =
"unexpected redo";
1772 mesg =
"retry outside of rescue clause";
1779 val = GET_EC()->tag->retval;
1781 return make_localjump_error(mesg, val, state);
1785 rb_vm_jump_tag_but_local_jump(
int state)
1787 VALUE exc = rb_vm_make_jump_tag_but_local_jump(state,
Qundef);
1789 EC_JUMP_TAG(GET_EC(), state);
1795 while (VM_ENV_LOCAL_P(cfp->ep)) {
1796 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
1807 const VALUE *ep = VM_CF_PREV_EP(cfp);
1812 rb_vm_localjump_error(
"unexpected break", val, TAG_BREAK);
1816 ec->errinfo = (
VALUE)THROW_DATA_NEW(val, target_cfp, TAG_BREAK);
1817 EC_JUMP_TAG(ec, TAG_BREAK);
1823 vm_iter_break(GET_EC(),
Qnil);
1829 vm_iter_break(GET_EC(), val);
1834 static st_table *vm_opt_method_def_table = 0;
1835 static st_table *vm_opt_mid_table = 0;
1838 vm_redefinition_check_flag(
VALUE klass)
1840 if (klass ==
rb_cInteger)
return INTEGER_REDEFINED_OP_FLAG;
1841 if (klass ==
rb_cFloat)
return FLOAT_REDEFINED_OP_FLAG;
1842 if (klass ==
rb_cString)
return STRING_REDEFINED_OP_FLAG;
1843 if (klass ==
rb_cArray)
return ARRAY_REDEFINED_OP_FLAG;
1844 if (klass ==
rb_cHash)
return HASH_REDEFINED_OP_FLAG;
1845 if (klass ==
rb_cSymbol)
return SYMBOL_REDEFINED_OP_FLAG;
1847 if (klass ==
rb_cTime)
return TIME_REDEFINED_OP_FLAG;
1849 if (klass ==
rb_cRegexp)
return REGEXP_REDEFINED_OP_FLAG;
1850 if (klass ==
rb_cNilClass)
return NIL_REDEFINED_OP_FLAG;
1853 if (klass ==
rb_cProc)
return PROC_REDEFINED_OP_FLAG;
1858 rb_vm_check_optimizable_mid(
VALUE mid)
1860 if (!vm_opt_mid_table) {
1864 return st_lookup(vm_opt_mid_table, mid, NULL);
1870 if (me->called_id != me->def->original_id) {
1875 switch (def->type) {
1876 case VM_METHOD_TYPE_CFUNC:
1877 case VM_METHOD_TYPE_OPTIMIZED:
1892 if (vm_redefinition_check_method_type(me)) {
1893 if (st_lookup(vm_opt_method_def_table, (st_data_t)me->def, &bop)) {
1894 int flag = vm_redefinition_check_flag(klass);
1896 rb_yjit_bop_redefined(klass, me, (
enum ruby_basic_operators)bop);
1897 ruby_vm_redefined_flag[bop] |= flag;
1903 static enum rb_id_table_iterator_result
1904 check_redefined_method(
ID mid,
VALUE value,
void *data)
1910 if (newme != me) rb_vm_check_redefinition_opt_method(me, me->owner);
1912 return ID_TABLE_CONTINUE;
1916 rb_vm_check_redefinition_by_prepend(
VALUE klass)
1918 if (!vm_redefinition_check_flag(klass))
return;
1919 rb_id_table_foreach(RCLASS_M_TBL(RCLASS_ORIGIN(klass)), check_redefined_method, (
void *)klass);
1927 if (me && vm_redefinition_check_method_type(me)) {
1928 st_insert(vm_opt_method_def_table, (st_data_t)me->def, (st_data_t)bop);
1929 st_insert(vm_opt_mid_table, (st_data_t)mid, (st_data_t)
Qtrue);
1937 vm_init_redefined_flag(
void)
1942 vm_opt_method_def_table = st_init_numtable();
1943 vm_opt_mid_table = st_init_numtable();
1945 #define OP(mid_, bop_) (mid = id##mid_, bop = BOP_##bop_, ruby_vm_redefined_flag[bop] = 0)
1946 #define C(k) add_opt_method(rb_c##k, mid, bop)
1947 OP(PLUS, PLUS), (C(Integer), C(Float), C(String), C(Array));
1948 OP(MINUS, MINUS), (C(Integer), C(Float));
1949 OP(MULT, MULT), (C(Integer), C(Float));
1950 OP(DIV, DIV), (C(Integer), C(Float));
1951 OP(MOD, MOD), (C(Integer), C(Float));
1952 OP(Eq, EQ), (C(Integer), C(Float), C(String), C(Symbol));
1953 OP(Eqq, EQQ), (C(Integer), C(Float), C(Symbol), C(String),
1954 C(NilClass), C(TrueClass), C(FalseClass));
1955 OP(LT, LT), (C(Integer), C(Float));
1956 OP(LE, LE), (C(Integer), C(Float));
1957 OP(GT, GT), (C(Integer), C(Float));
1958 OP(GE, GE), (C(Integer), C(Float));
1959 OP(LTLT, LTLT), (C(String), C(Array));
1960 OP(AREF, AREF), (C(Array), C(Hash), C(Integer));
1961 OP(ASET, ASET), (C(Array), C(Hash));
1962 OP(Length, LENGTH), (C(Array), C(String), C(Hash));
1963 OP(Size, SIZE), (C(Array), C(String), C(Hash));
1964 OP(EmptyP, EMPTY_P), (C(Array), C(String), C(Hash));
1965 OP(Succ, SUCC), (C(Integer), C(String));
1966 OP(EqTilde, MATCH), (C(
Regexp), C(String));
1967 OP(Freeze, FREEZE), (C(String));
1968 OP(UMinus, UMINUS), (C(String));
1969 OP(Max, MAX), (C(Array));
1970 OP(Min, MIN), (C(Array));
1971 OP(Call, CALL), (C(Proc));
1972 OP(And, AND), (C(Integer));
1973 OP(Or, OR), (C(Integer));
1974 OP(NilP,
NIL_P), (C(NilClass));
1985 switch (VM_FRAME_TYPE(cfp)) {
1986 case VM_FRAME_MAGIC_METHOD:
return "method";
1987 case VM_FRAME_MAGIC_BLOCK:
return "block";
1988 case VM_FRAME_MAGIC_CLASS:
return "class";
1989 case VM_FRAME_MAGIC_TOP:
return "top";
1990 case VM_FRAME_MAGIC_CFUNC:
return "cfunc";
1991 case VM_FRAME_MAGIC_IFUNC:
return "ifunc";
1992 case VM_FRAME_MAGIC_EVAL:
return "eval";
1993 case VM_FRAME_MAGIC_RESCUE:
return "rescue";
2003 if (THROW_DATA_P(err) &&
2004 THROW_DATA_STATE(err) == TAG_BREAK &&
2005 THROW_DATA_CONSUMED_P(err) == FALSE) {
2006 return THROW_DATA_VAL(err);
2018 unsigned long type = VM_FRAME_TYPE(cfp);
2019 #define C(t) if (type == VM_FRAME_MAGIC_##t) return #t
2040 bool cfp_returning_with_value,
int state,
struct vm_throw_data *err)
2049 switch (VM_FRAME_TYPE(ec->cfp)) {
2050 case VM_FRAME_MAGIC_METHOD:
2051 RUBY_DTRACE_METHOD_RETURN_HOOK(ec, 0, 0);
2052 EXEC_EVENT_HOOK_AND_POP_FRAME(ec,
RUBY_EVENT_RETURN, ec->cfp->self, 0, 0, 0, frame_return_value(err));
2056 ec->cfp->self, 0, 0, 0, frame_return_value(err), TRUE);
2059 THROW_DATA_CONSUMED_SET(err);
2061 case VM_FRAME_MAGIC_BLOCK:
2062 if (VM_FRAME_BMETHOD_P(ec->cfp)) {
2063 VALUE bmethod_return_value = frame_return_value(err);
2064 if (cfp_returning_with_value) {
2066 bmethod_return_value = THROW_DATA_VAL(err);
2073 ec->cfp->self, 0, 0, 0, bmethod_return_value, FALSE);
2079 rb_vm_frame_method_entry(ec->cfp)->def->original_id,
2080 rb_vm_frame_method_entry(ec->cfp)->called_id,
2081 rb_vm_frame_method_entry(ec->cfp)->owner,
2082 bmethod_return_value);
2084 VM_ASSERT(me->def->type == VM_METHOD_TYPE_BMETHOD);
2085 local_hooks = me->def->body.bmethod.hooks;
2089 rb_vm_frame_method_entry(ec->cfp)->def->original_id,
2090 rb_vm_frame_method_entry(ec->cfp)->called_id,
2091 rb_vm_frame_method_entry(ec->cfp)->owner,
2092 bmethod_return_value, TRUE);
2094 THROW_DATA_CONSUMED_SET(err);
2097 EXEC_EVENT_HOOK_AND_POP_FRAME(ec,
RUBY_EVENT_B_RETURN, ec->cfp->self, 0, 0, 0, frame_return_value(err));
2100 ec->cfp->self, 0, 0, 0, frame_return_value(err), TRUE);
2102 THROW_DATA_CONSUMED_SET(err);
2105 case VM_FRAME_MAGIC_CLASS:
2202 enum ruby_tag_type state;
2209 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
2210 if (!mjit_enable_p || (result = mjit_exec(ec)) ==
Qundef) {
2211 result = vm_exec_core(ec, initial);
2216 result = ec->errinfo;
2217 rb_ec_raised_reset(ec, RAISED_STACKOVERFLOW | RAISED_NOMEMORY);
2218 while ((result = vm_exec_handle_exception(ec, state, result, &initial)) ==
Qundef) {
2220 result = vm_exec_core(ec, initial);
2222 VM_ASSERT(ec->tag == &_tag);
2224 if ((state = _tag.state) == TAG_NONE)
break;
2225 _tag.state = TAG_NONE;
2242 unsigned long epc, cont_pc, cont_sp;
2248 cont_pc = cont_sp = 0;
2251 while (ec->cfp->pc == 0 || ec->cfp->iseq == 0) {
2252 if (UNLIKELY(VM_FRAME_TYPE(ec->cfp) == VM_FRAME_MAGIC_CFUNC)) {
2254 rb_vm_frame_method_entry(ec->cfp)->def->original_id,
2255 rb_vm_frame_method_entry(ec->cfp)->called_id,
2256 rb_vm_frame_method_entry(ec->cfp)->owner,
Qnil);
2257 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec,
2258 rb_vm_frame_method_entry(ec->cfp)->owner,
2259 rb_vm_frame_method_entry(ec->cfp)->def->original_id);
2261 rb_vm_pop_frame(ec);
2265 epc = cfp->pc - cfp->iseq->body->iseq_encoded;
2268 if (state == TAG_BREAK || state == TAG_RETURN) {
2269 escape_cfp = THROW_DATA_CATCH_FRAME(err);
2271 if (cfp == escape_cfp) {
2272 if (state == TAG_RETURN) {
2273 if (!VM_FRAME_FINISHED_P(cfp)) {
2274 THROW_DATA_CATCH_FRAME_SET(err, cfp + 1);
2275 THROW_DATA_STATE_SET(err, state = TAG_BREAK);
2278 ct = cfp->iseq->body->catch_table;
2279 if (ct)
for (i = 0; i < ct->size; i++) {
2280 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2281 if (entry->start < epc && entry->end >= epc) {
2282 if (entry->type == CATCH_TYPE_ENSURE) {
2283 catch_iseq = entry->iseq;
2284 cont_pc = entry->cont;
2285 cont_sp = entry->sp;
2290 if (catch_iseq == NULL) {
2292 THROW_DATA_CATCH_FRAME_SET(err, cfp + 1);
2294 hook_before_rewind(ec, ec->cfp,
true, state, err);
2295 rb_vm_pop_frame(ec);
2296 return THROW_DATA_VAL(err);
2303 #if OPT_STACK_CACHING
2304 *initial = THROW_DATA_VAL(err);
2306 *ec->cfp->sp++ = THROW_DATA_VAL(err);
2314 if (state == TAG_RAISE) {
2315 ct = cfp->iseq->body->catch_table;
2316 if (ct)
for (i = 0; i < ct->size; i++) {
2317 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2318 if (entry->start < epc && entry->end >= epc) {
2320 if (entry->type == CATCH_TYPE_RESCUE ||
2321 entry->type == CATCH_TYPE_ENSURE) {
2322 catch_iseq = entry->iseq;
2323 cont_pc = entry->cont;
2324 cont_sp = entry->sp;
2330 else if (state == TAG_RETRY) {
2331 ct = cfp->iseq->body->catch_table;
2332 if (ct)
for (i = 0; i < ct->size; i++) {
2333 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2334 if (entry->start < epc && entry->end >= epc) {
2336 if (entry->type == CATCH_TYPE_ENSURE) {
2337 catch_iseq = entry->iseq;
2338 cont_pc = entry->cont;
2339 cont_sp = entry->sp;
2342 else if (entry->type == CATCH_TYPE_RETRY) {
2344 escape_cfp = THROW_DATA_CATCH_FRAME(err);
2345 if (cfp == escape_cfp) {
2346 cfp->pc = cfp->iseq->body->iseq_encoded + entry->cont;
2354 else if ((state == TAG_BREAK && !escape_cfp) ||
2355 (state == TAG_REDO) ||
2356 (state == TAG_NEXT)) {
2357 type = (
const enum catch_type[TAG_MASK]) {
2358 [TAG_BREAK] = CATCH_TYPE_BREAK,
2359 [TAG_NEXT] = CATCH_TYPE_NEXT,
2360 [TAG_REDO] = CATCH_TYPE_REDO,
2364 ct = cfp->iseq->body->catch_table;
2365 if (ct)
for (i = 0; i < ct->size; i++) {
2366 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2368 if (entry->start < epc && entry->end >= epc) {
2369 if (entry->type == CATCH_TYPE_ENSURE) {
2370 catch_iseq = entry->iseq;
2371 cont_pc = entry->cont;
2372 cont_sp = entry->sp;
2375 else if (entry->type ==
type) {
2376 cfp->pc = cfp->iseq->body->iseq_encoded + entry->cont;
2377 cfp->sp = vm_base_ptr(cfp) + entry->sp;
2379 if (state != TAG_REDO) {
2380 #if OPT_STACK_CACHING
2381 *initial = THROW_DATA_VAL(err);
2383 *ec->cfp->sp++ = THROW_DATA_VAL(err);
2387 VM_ASSERT(ec->tag->state == TAG_NONE);
2394 ct = cfp->iseq->body->catch_table;
2395 if (ct)
for (i = 0; i < ct->size; i++) {
2396 entry = UNALIGNED_MEMBER_PTR(ct, entries[i]);
2397 if (entry->start < epc && entry->end >= epc) {
2399 if (entry->type == CATCH_TYPE_ENSURE) {
2400 catch_iseq = entry->iseq;
2401 cont_pc = entry->cont;
2402 cont_sp = entry->sp;
2409 if (catch_iseq != NULL) {
2411 const int arg_size = 1;
2413 rb_iseq_check(catch_iseq);
2414 cfp->sp = vm_base_ptr(cfp) + cont_sp;
2415 cfp->pc = cfp->iseq->body->iseq_encoded + cont_pc;
2418 cfp->sp[0] = (
VALUE)err;
2419 vm_push_frame(ec, catch_iseq, VM_FRAME_MAGIC_RESCUE,
2421 VM_GUARDED_PREV_EP(cfp->ep),
2423 catch_iseq->body->iseq_encoded,
2424 cfp->sp + arg_size ,
2425 catch_iseq->body->local_table_size - arg_size,
2426 catch_iseq->body->stack_max);
2429 ec->tag->state = TAG_NONE;
2435 hook_before_rewind(ec, ec->cfp, (cfp == escape_cfp), state, err);
2437 if (VM_FRAME_FINISHED_P(ec->cfp)) {
2438 rb_vm_pop_frame(ec);
2439 ec->errinfo = (
VALUE)err;
2440 ec->tag = ec->tag->prev;
2441 EC_JUMP_TAG(ec, state);
2444 rb_vm_pop_frame(ec);
2457 vm_set_top_stack(ec, iseq);
2458 val = vm_exec(ec,
true);
2463 rb_iseq_eval_main(
const rb_iseq_t *iseq)
2468 vm_set_main_stack(ec, iseq);
2469 val = vm_exec(ec,
true);
2479 if (idp) *idp = me->def->original_id;
2480 if (called_idp) *called_idp = me->called_id;
2481 if (klassp) *klassp = me->owner;
2492 return rb_vm_control_frame_id_and_class(ec->cfp, idp, called_idp, klassp);
2498 return rb_ec_frame_method_id_and_class(GET_EC(), idp, 0, klassp);
2507 const rb_iseq_t *iseq = rb_iseq_new(0, filename, filename,
Qnil, 0, ISEQ_TYPE_TOP);
2510 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_TOP | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH,
2511 recv, block_handler,
2512 (
VALUE)vm_cref_new_toplevel(ec),
2513 0, reg_cfp->sp, 0, 0);
2517 rb_vm_pop_frame(ec);
2524 rb_vm_update_references(
void *ptr)
2534 if (vm->load_path_check_cache) {
2535 vm->load_path_check_cache =
rb_gc_location(vm->load_path_check_cache);
2540 vm->loaded_features_snapshot =
rb_gc_location(vm->loaded_features_snapshot);
2541 vm->loaded_features_realpaths =
rb_gc_location(vm->loaded_features_realpaths);
2547 if (vm->coverages) {
2555 rb_vm_each_stack_value(
void *ptr,
void (*cb)(
VALUE,
void*),
void *ctx)
2560 list_for_each(&vm->ractor.set, r, vmlr_node) {
2561 VM_ASSERT(rb_ractor_status_p(r, ractor_blocking) ||
2562 rb_ractor_status_p(r, ractor_running));
2563 if (r->threads.cnt > 0) {
2565 list_for_each(&r->threads.set, th, lt_node) {
2566 VM_ASSERT(th != NULL);
2569 VALUE *p = ec->vm_stack;
2570 VALUE *sp = ec->cfp->sp;
2584 static enum rb_id_table_iterator_result
2585 vm_mark_negative_cme(
VALUE val,
void *dmy)
2588 return ID_TABLE_CONTINUE;
2592 rb_vm_mark(
void *ptr)
2594 RUBY_MARK_ENTER(
"vm");
2595 RUBY_GC_INFO(
"-------------------------------------------------\n");
2600 const VALUE *obj_ary;
2602 list_for_each(&vm->ractor.set, r, vmlr_node) {
2604 VM_ASSERT(rb_ractor_status_p(r, ractor_blocking) ||
2605 rb_ractor_status_p(r, ractor_running));
2613 for (i=0; i < len; i++) {
2620 for (j=0; j < jlen; j++) {
2628 RUBY_MARK_MOVABLE_UNLESS_NULL(vm->load_path_check_cache);
2635 RUBY_MARK_MOVABLE_UNLESS_NULL(vm->coverages);
2636 RUBY_MARK_MOVABLE_UNLESS_NULL(vm->me2counter);
2640 if (vm->loading_table) {
2644 rb_gc_mark_values(RUBY_NSIG, vm->trap_list.cmd);
2646 rb_id_table_foreach_values(vm->negative_cme_table, vm_mark_negative_cme, NULL);
2648 for (i=0; i<VM_GLOBAL_CC_CACHE_TABLE_SIZE; i++) {
2649 const struct rb_callcache *cc = vm->global_cc_cache_table[i];
2652 if (!vm_cc_invalidated_p(cc)) {
2656 vm->global_cc_cache_table[i] = NULL;
2664 RUBY_MARK_LEAVE(
"vm");
2667 #undef rb_vm_register_special_exception
2669 rb_vm_register_special_exception_str(
enum ruby_special_exceptions sp,
VALUE cls,
VALUE mesg)
2674 ((
VALUE *)vm->special_exceptions)[sp] = exc;
2679 rb_vm_add_root_module(
VALUE module)
2683 st_insert(vm->defined_module_hash, (st_data_t)module, (st_data_t)module);
2689 free_loading_table_entry(st_data_t key, st_data_t value, st_data_t arg)
2698 RUBY_FREE_ENTER(
"vm");
2703 vm->ractor.main_thread = NULL;
2706 rb_fiber_reset_root_local_storage(th);
2709 rb_vm_living_threads_init(vm);
2710 ruby_vm_run_at_exit_hooks(vm);
2711 if (vm->loading_table) {
2712 st_foreach(vm->loading_table, free_loading_table_entry, 0);
2713 st_free_table(vm->loading_table);
2714 vm->loading_table = 0;
2716 if (vm->frozen_strings) {
2717 st_free_table(vm->frozen_strings);
2718 vm->frozen_strings = 0;
2720 RB_ALTSTACK_FREE(vm->main_altstack);
2722 rb_objspace_free(objspace);
2728 ruby_current_vm_ptr = NULL;
2730 RUBY_FREE_LEAVE(
"vm");
2735 vm_memsize(
const void *ptr)
2737 size_t size =
sizeof(
rb_vm_t);
2747 {0, 0, vm_memsize,},
2748 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
2753 vm_default_params(
void)
2756 VALUE result = rb_hash_new_with_size(4);
2757 #define SET(name) rb_hash_aset(result, ID2SYM(rb_intern(#name)), SIZET2NUM(vm->default_params.name));
2758 SET(thread_vm_stack_size);
2759 SET(thread_machine_stack_size);
2760 SET(fiber_vm_stack_size);
2761 SET(fiber_machine_stack_size);
2768 get_param(
const char *name,
size_t default_value,
size_t min_value)
2771 size_t result = default_value;
2772 if ((envval = getenv(name)) != 0) {
2773 long val = atol(envval);
2774 if (val < (
long)min_value) {
2775 val = (long)min_value;
2777 result = (size_t)(((val -1 + RUBY_VM_SIZE_ALIGN) / RUBY_VM_SIZE_ALIGN) * RUBY_VM_SIZE_ALIGN);
2779 if (0) ruby_debug_printf(
"%s: %"PRIuSIZE
"\n", name, result);
2785 check_machine_stack_size(
size_t *sizep)
2787 #ifdef PTHREAD_STACK_MIN
2788 size_t size = *sizep;
2791 #ifdef PTHREAD_STACK_MIN
2792 if (size < (
size_t)PTHREAD_STACK_MIN) {
2793 *sizep = (size_t)PTHREAD_STACK_MIN * 2;
2799 vm_default_params_setup(
rb_vm_t *vm)
2801 vm->default_params.thread_vm_stack_size =
2802 get_param(
"RUBY_THREAD_VM_STACK_SIZE",
2803 RUBY_VM_THREAD_VM_STACK_SIZE,
2804 RUBY_VM_THREAD_VM_STACK_SIZE_MIN);
2806 vm->default_params.thread_machine_stack_size =
2807 get_param(
"RUBY_THREAD_MACHINE_STACK_SIZE",
2808 RUBY_VM_THREAD_MACHINE_STACK_SIZE,
2809 RUBY_VM_THREAD_MACHINE_STACK_SIZE_MIN);
2811 vm->default_params.fiber_vm_stack_size =
2812 get_param(
"RUBY_FIBER_VM_STACK_SIZE",
2813 RUBY_VM_FIBER_VM_STACK_SIZE,
2814 RUBY_VM_FIBER_VM_STACK_SIZE_MIN);
2816 vm->default_params.fiber_machine_stack_size =
2817 get_param(
"RUBY_FIBER_MACHINE_STACK_SIZE",
2818 RUBY_VM_FIBER_MACHINE_STACK_SIZE,
2819 RUBY_VM_FIBER_MACHINE_STACK_SIZE_MIN);
2822 check_machine_stack_size(&vm->default_params.thread_machine_stack_size);
2823 check_machine_stack_size(&vm->default_params.fiber_machine_stack_size);
2830 rb_vm_living_threads_init(vm);
2831 vm->thread_report_on_exception = 1;
2832 vm->src_encoding_index = -1;
2834 vm_default_params_setup(vm);
2844 VALUE *p = ec->vm_stack;
2845 VALUE *sp = ec->cfp->sp;
2849 for (i = 0; i < (long)(sp - p); i++) {
2852 if (ref != update) {
2857 while (cfp != limit_cfp) {
2858 const VALUE *ep = cfp->ep;
2863 if (!VM_ENV_LOCAL_P(ep)) {
2864 const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
2865 if (VM_ENV_FLAGS(prev_ep, VM_ENV_FLAG_ESCAPED)) {
2866 VM_FORCE_WRITE(&prev_ep[VM_ENV_DATA_INDEX_ENV],
rb_gc_location(prev_ep[VM_ENV_DATA_INDEX_ENV]));
2869 if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED)) {
2870 VM_FORCE_WRITE(&ep[VM_ENV_DATA_INDEX_ENV],
rb_gc_location(ep[VM_ENV_DATA_INDEX_ENV]));
2871 VM_FORCE_WRITE(&ep[VM_ENV_DATA_INDEX_ME_CREF],
rb_gc_location(ep[VM_ENV_DATA_INDEX_ME_CREF]));
2875 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
2880 static enum rb_id_table_iterator_result
2881 mark_local_storage_i(
VALUE local,
void *data)
2884 return ID_TABLE_CONTINUE;
2893 VALUE *p = ec->vm_stack;
2894 VALUE *sp = ec->cfp->sp;
2898 VM_ASSERT(sp == ec->cfp->sp);
2899 rb_gc_mark_vm_stack_values((
long)(sp - p), p);
2901 while (cfp != limit_cfp) {
2902 const VALUE *ep = cfp->ep;
2903 VM_ASSERT(!!VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED) == vm_ep_in_heap_p_(ec, ep));
2908 if (!VM_ENV_LOCAL_P(ep)) {
2909 const VALUE *prev_ep = VM_ENV_PREV_EP(ep);
2910 if (VM_ENV_FLAGS(prev_ep, VM_ENV_FLAG_ESCAPED)) {
2914 if (VM_ENV_FLAGS(ep, VM_ENV_FLAG_ESCAPED)) {
2920 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
2925 if (ec->machine.stack_start && ec->machine.stack_end &&
2928 rb_gc_mark_machine_stack(ec);
2930 (
VALUE *)(&ec->machine.regs) +
2931 sizeof(ec->machine.regs) / (
sizeof(
VALUE)));
2934 RUBY_MARK_UNLESS_NULL(ec->errinfo);
2935 RUBY_MARK_UNLESS_NULL(ec->root_svar);
2936 if (ec->local_storage) {
2937 rb_id_table_foreach_values(ec->local_storage, mark_local_storage_i, NULL);
2939 RUBY_MARK_UNLESS_NULL(ec->local_storage_recursive_hash);
2940 RUBY_MARK_UNLESS_NULL(ec->local_storage_recursive_hash_for_trace);
2941 RUBY_MARK_UNLESS_NULL(ec->private_const_reference);
2946 void rb_threadptr_root_fiber_setup(
rb_thread_t *th);
2947 void rb_threadptr_root_fiber_release(
rb_thread_t *th);
2950 thread_compact(
void *ptr)
2956 if (!th->root_fiber) {
2957 rb_execution_context_update(th->ec);
2962 thread_mark(
void *ptr)
2965 RUBY_MARK_ENTER(
"thread");
2966 rb_fiber_mark_self(th->ec->fiber_ptr);
2969 switch (th->invoke_type) {
2970 case thread_invoke_type_proc:
2971 case thread_invoke_type_ractor_proc:
2972 RUBY_MARK_UNLESS_NULL(th->invoke_arg.proc.proc);
2973 RUBY_MARK_UNLESS_NULL(th->invoke_arg.proc.args);
2975 case thread_invoke_type_func:
2983 RUBY_MARK_UNLESS_NULL(th->thgroup);
2984 RUBY_MARK_UNLESS_NULL(th->value);
2985 RUBY_MARK_UNLESS_NULL(th->pending_interrupt_queue);
2986 RUBY_MARK_UNLESS_NULL(th->pending_interrupt_mask_stack);
2987 RUBY_MARK_UNLESS_NULL(th->top_self);
2988 RUBY_MARK_UNLESS_NULL(th->top_wrapper);
2989 if (th->root_fiber) rb_fiber_mark_self(th->root_fiber);
2992 rb_execution_context_mark(th->ec);
2993 RUBY_MARK_UNLESS_NULL(th->stat_insn_usage);
2994 RUBY_MARK_UNLESS_NULL(th->last_status);
2995 RUBY_MARK_UNLESS_NULL(th->locking_mutex);
2996 RUBY_MARK_UNLESS_NULL(th->name);
2998 RUBY_MARK_UNLESS_NULL(th->scheduler);
3000 RUBY_MARK_LEAVE(
"thread");
3004 thread_free(
void *ptr)
3007 RUBY_FREE_ENTER(
"thread");
3009 if (th->locking_mutex !=
Qfalse) {
3010 rb_bug(
"thread_free: locking_mutex must be NULL (%p:%p)", (
void *)th, (
void *)th->locking_mutex);
3012 if (th->keeping_mutexes != NULL) {
3013 rb_bug(
"thread_free: keeping_mutexes must be NULL (%p:%p)", (
void *)th, (
void *)th->keeping_mutexes);
3016 rb_threadptr_root_fiber_release(th);
3018 if (th->vm && th->vm->ractor.main_thread == th) {
3019 RUBY_GC_INFO(
"MRI main thread\n");
3025 RUBY_FREE_LEAVE(
"thread");
3029 thread_memsize(
const void *ptr)
3034 if (!th->root_fiber) {
3035 size += th->ec->vm_stack_size *
sizeof(
VALUE);
3037 if (th->ec->local_storage) {
3038 size += rb_id_table_memsize(th->ec->local_storage);
3043 #define thread_data_type ruby_threadptr_data_type
3052 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
3056 rb_obj_is_thread(
VALUE obj)
3062 thread_alloc(
VALUE klass)
3074 ec->vm_stack = stack;
3075 ec->vm_stack_size = size;
3081 rb_ec_set_vm_stack(ec, stack, size);
3083 ec->cfp = (
void *)(ec->vm_stack + ec->vm_stack_size);
3087 VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH | VM_FRAME_FLAG_CFRAME ,
3088 Qnil , VM_BLOCK_HANDLER_NONE ,
3090 0 , ec->vm_stack, 0, 0
3097 rb_ec_set_vm_stack(ec, NULL, 0);
3107 rb_threadptr_root_fiber_setup(th);
3111 th->scheduler =
Qnil;
3114 size_t size = th->vm->default_params.thread_vm_stack_size /
sizeof(
VALUE);
3115 rb_ec_initialize_vm_stack(th->ec,
ALLOC_N(
VALUE, size), size);
3118 VM_ASSERT(th->ec->cfp == NULL);
3119 VM_ASSERT(th->ec->vm_stack == NULL);
3120 VM_ASSERT(th->ec->vm_stack_size == 0);
3123 th->status = THREAD_RUNNABLE;
3124 th->last_status =
Qnil;
3125 th->ec->errinfo =
Qnil;
3126 th->ec->root_svar =
Qfalse;
3127 th->ec->local_storage_recursive_hash =
Qnil;
3128 th->ec->local_storage_recursive_hash_for_trace =
Qnil;
3129 #ifdef NON_SCALAR_THREAD_ID
3130 th->thread_id_string[0] =
'\0';
3135 #if OPT_CALL_THREADED_CODE
3139 th->report_on_exception = th->vm->thread_report_on_exception;
3140 th->ext_config.ractor_safe =
true;
3144 ruby_thread_init(
VALUE self)
3151 th_init(target_th,
self);
3153 target_th->top_wrapper = 0;
3154 target_th->top_self = rb_vm_top_self();
3155 target_th->ec->root_svar =
Qfalse;
3156 target_th->ractor = th->ractor;
3162 rb_thread_alloc(
VALUE klass)
3164 VALUE self = thread_alloc(klass);
3165 ruby_thread_init(
self);
3169 #define REWIND_CFP(expr) do { \
3170 rb_execution_context_t *ec__ = GET_EC(); \
3171 VALUE *const curr_sp = (ec__->cfp++)->sp; \
3172 VALUE *const saved_sp = ec__->cfp->sp; \
3173 ec__->cfp->sp = curr_sp; \
3175 (ec__->cfp--)->sp = saved_sp; \
3202 rb_clear_method_cache(
self, mid);
3208 m_core_set_postexe(
VALUE self)
3217 core_hash_merge(
VALUE hash,
long argc,
const VALUE *argv)
3220 VM_ASSERT(argc % 2 == 0);
3226 m_core_hash_merge_ptr(
int argc,
VALUE *argv,
VALUE recv)
3228 VALUE hash = argv[0];
3230 REWIND_CFP(hash = core_hash_merge(hash, argc-1, argv+1));
3245 REWIND_CFP(hash = core_hash_merge_kwd(hash, kw));
3256 m_core_make_shareable_copy(
VALUE recv,
VALUE obj)
3264 return rb_ractor_ensure_shareable(obj, name);
3278 return RBOOL(mjit_enabled);
3282 mjit_pause_m(
int argc,
VALUE *argv, RB_UNUSED_VAR(
VALUE self))
3288 if (!
NIL_P(options)) {
3289 static ID keyword_ids[1];
3290 if (!keyword_ids[0])
3295 return mjit_pause(
RTEST(wait));
3301 return mjit_resume();
3304 extern VALUE *rb_gc_stack_start;
3305 extern size_t rb_gc_stack_maxsize;
3313 rb_vm_bugreport(NULL);
3322 #ifdef HAVE_BACKTRACE
3323 #include <execinfo.h>
3324 #define MAX_NATIVE_TRACE 1024
3325 static void *trace[MAX_NATIVE_TRACE];
3326 int n = (int)backtrace(trace, MAX_NATIVE_TRACE);
3327 char **syms = backtrace_symbols(trace, n);
3334 for (i=0; i<n; i++) {
3342 #if VM_COLLECT_USAGE_DETAILS
3343 static VALUE usage_analysis_insn_start(
VALUE self);
3344 static VALUE usage_analysis_operand_start(
VALUE self);
3345 static VALUE usage_analysis_register_start(
VALUE self);
3346 static VALUE usage_analysis_insn_stop(
VALUE self);
3347 static VALUE usage_analysis_operand_stop(
VALUE self);
3348 static VALUE usage_analysis_register_stop(
VALUE self);
3349 static VALUE usage_analysis_insn_running(
VALUE self);
3350 static VALUE usage_analysis_operand_running(
VALUE self);
3351 static VALUE usage_analysis_register_running(
VALUE self);
3352 static VALUE usage_analysis_insn_clear(
VALUE self);
3353 static VALUE usage_analysis_operand_clear(
VALUE self);
3354 static VALUE usage_analysis_register_clear(
VALUE self);
3360 return rb_f_raise(c, v);
3407 vm_keep_script_lines(
VALUE self)
3409 return RBOOL(ruby_vm_keep_script_lines);
3424 vm_keep_script_lines_set(
VALUE self,
VALUE flags)
3426 ruby_vm_keep_script_lines =
RTEST(flags);
3455 #if USE_DEBUG_COUNTER
3476 rb_define_method(klass,
"make_shareable_copy", m_core_make_shareable_copy, 1);
3479 RBASIC_CLEAR_CLASS(klass);
3482 rb_mRubyVMFrozenCore = fcore;
3654 #if VM_COLLECT_USAGE_DETAILS
3656 #define define_usage_analysis_hash(name) \
3657 rb_define_const(rb_cRubyVM, "USAGE_ANALYSIS_" #name, rb_hash_new())
3658 define_usage_analysis_hash(
INSN);
3659 define_usage_analysis_hash(REGS);
3660 define_usage_analysis_hash(INSN_BIGRAM);
3682 #if OPT_DIRECT_THREADED_CODE
3684 #elif OPT_TOKEN_THREADED_CODE
3686 #elif OPT_CALL_THREADED_CODE
3690 #if OPT_STACK_CACHING
3693 #if OPT_OPERANDS_UNIFICATION
3696 #if OPT_INSTRUCTIONS_UNIFICATION
3699 #if OPT_INLINE_METHOD_CACHE
3702 #if OPT_BLOCKINLINING
3710 rb_define_const(rb_cRubyVM,
"INSTRUCTION_NAMES", rb_insns_name_array());
3735 rb_vm_t *vm = ruby_current_vm_ptr;
3737 VALUE filename = rb_fstring_lit(
"<main>");
3738 const rb_iseq_t *iseq = rb_iseq_new(0, filename, filename,
Qnil, 0, ISEQ_TYPE_TOP);
3741 rb_ractor_main_setup(vm, th->ractor, th);
3748 vm->ractor.main_thread = th;
3749 vm->ractor.main_ractor = th->ractor;
3751 th->top_wrapper = 0;
3752 th->top_self = rb_vm_top_self();
3755 th->ec->cfp->iseq = iseq;
3756 th->ec->cfp->pc = iseq->body->iseq_encoded;
3757 th->ec->cfp->self = th->top_self;
3759 VM_ENV_FLAGS_UNSET(th->ec->cfp->ep, VM_FRAME_FLAG_CFRAME);
3760 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));
3767 rb_objspace_gc_enable(vm->objspace);
3769 vm_init_redefined_flag();
3773 OPTIMIZED_METHOD_TYPE_BLOCK_CALL, 0, METHOD_VISI_PUBLIC);
3778 Init_vm_backtrace();
3782 rb_vm_set_progname(
VALUE filename)
3788 rb_iseq_pathobj_set(cfp->iseq,
rb_str_dup(filename), rb_iseq_realpath(cfp->iseq));
3797 rb_vm_t * vm = ruby_mimmalloc(
sizeof(*vm));
3800 fputs(
"[FATAL] failed to allocate memory\n", stderr);
3806 vm->objspace = rb_objspace_alloc();
3807 ruby_current_vm_ptr = vm;
3808 vm->negative_cme_table = rb_id_table_create(16);
3809 vm->overloaded_cme_table = st_init_numtable();
3811 Init_native_thread(th);
3814 vm->ractor.main_ractor = th->ractor = rb_ractor_main_alloc();
3815 rb_ractor_set_current_ec(th->ractor, th->ec);
3816 ruby_thread_init_stack(th);
3824 Init_vm_objects(
void)
3828 vm->defined_module_hash = st_init_numtable();
3832 vm->loading_table = st_init_strtable();
3833 vm->frozen_strings = st_init_table_with_size(&rb_fstring_hash_type, 10000);
3835 vm->static_ext_inits = st_init_strtable();
3842 main_to_s(
VALUE obj)
3848 rb_vm_top_self(
void)
3850 return GET_VM()->top_self;
3867 return &cr->verbose;
3880 int len,
size_t pos,
VALUE *pnop,
VALUE child);
3883 rb_vm_fstring_table(
void)
3885 return GET_VM()->frozen_strings;
3888 #if VM_COLLECT_USAGE_DETAILS
3890 #define HASH_ASET(h, k, v) rb_hash_aset((h), (st_data_t)(k), (st_data_t)(v))
3904 vm_analysis_insn(
int insn)
3908 static int prev_insn = -1;
3914 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
3915 CONST_ID(bigram_hash,
"USAGE_ANALYSIS_INSN_BIGRAM");
3919 HASH_ASET(uh,
INT2FIX(insn), ihash);
3927 if (prev_insn != -1) {
3946 vm_analysis_operand(
int insn,
int n,
VALUE op)
3956 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
3961 HASH_ASET(uh,
INT2FIX(insn), ihash);
3965 HASH_ASET(ihash,
INT2FIX(n), ophash);
3968 valstr = rb_insn_operand_intern(GET_EC()->cfp->iseq, insn, n, op, 0, 0, 0, 0);
3978 vm_analysis_register(
int reg,
int isset)
3983 static const char regstrs[][5] = {
3991 static const char getsetstr[][4] = {
3995 static VALUE syms[
sizeof(regstrs) /
sizeof(regstrs[0])][2];
3999 CONST_ID(usage_hash,
"USAGE_ANALYSIS_REGS");
4004 for (i = 0; i < (int)(
sizeof(regstrs) /
sizeof(regstrs[0])); i++) {
4006 for (j = 0; j < 2; j++) {
4007 snprintf(buff, 0x10,
"%d %s %-4s", i, getsetstr[j], regstrs[i]);
4012 valstr = syms[reg][isset];
4023 static void (*ruby_vm_collect_usage_func_insn)(
int insn) = NULL;
4024 static void (*ruby_vm_collect_usage_func_operand)(
int insn,
int n,
VALUE op) = NULL;
4025 static void (*ruby_vm_collect_usage_func_register)(
int reg,
int isset) = NULL;
4029 usage_analysis_insn_start(
VALUE self)
4031 ruby_vm_collect_usage_func_insn = vm_analysis_insn;
4037 usage_analysis_operand_start(
VALUE self)
4039 ruby_vm_collect_usage_func_operand = vm_analysis_operand;
4045 usage_analysis_register_start(
VALUE self)
4047 ruby_vm_collect_usage_func_register = vm_analysis_register;
4053 usage_analysis_insn_stop(
VALUE self)
4055 ruby_vm_collect_usage_func_insn = 0;
4061 usage_analysis_operand_stop(
VALUE self)
4063 ruby_vm_collect_usage_func_operand = 0;
4069 usage_analysis_register_stop(
VALUE self)
4071 ruby_vm_collect_usage_func_register = 0;
4077 usage_analysis_insn_running(
VALUE self)
4079 return RBOOL(ruby_vm_collect_usage_func_insn != 0);
4084 usage_analysis_operand_running(
VALUE self)
4086 return RBOOL(ruby_vm_collect_usage_func_operand != 0);
4091 usage_analysis_register_running(
VALUE self)
4093 return RBOOL(ruby_vm_collect_usage_func_register != 0);
4098 usage_analysis_insn_clear(
VALUE self)
4105 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
4106 CONST_ID(bigram_hash,
"USAGE_ANALYSIS_INSN_BIGRAM");
4117 usage_analysis_operand_clear(
VALUE self)
4122 CONST_ID(usage_hash,
"USAGE_ANALYSIS_INSN");
4131 usage_analysis_register_clear(
VALUE self)
4136 CONST_ID(usage_hash,
"USAGE_ANALYSIS_REGS");
4145 MAYBE_UNUSED(
static void (*ruby_vm_collect_usage_func_insn)(
int insn)) = 0;
4146 MAYBE_UNUSED(
static void (*ruby_vm_collect_usage_func_operand)(
int insn,
int n,
VALUE op)) = 0;
4147 MAYBE_UNUSED(
static void (*ruby_vm_collect_usage_func_register)(
int reg,
int isset)) = 0;
4151 #if VM_COLLECT_USAGE_DETAILS
4154 vm_collect_usage_insn(
int insn)
4156 if (RUBY_DTRACE_INSN_ENABLED()) {
4157 RUBY_DTRACE_INSN(rb_insns_name(insn));
4159 if (ruby_vm_collect_usage_func_insn)
4160 (*ruby_vm_collect_usage_func_insn)(insn);
4168 vm_collect_usage_operand(
int insn,
int n,
VALUE op)
4170 if (RUBY_DTRACE_INSN_OPERAND_ENABLED()) {
4173 valstr = rb_insn_operand_intern(GET_EC()->cfp->iseq, insn, n, op, 0, 0, 0, 0);
4175 RUBY_DTRACE_INSN_OPERAND(
RSTRING_PTR(valstr), rb_insns_name(insn));
4178 if (ruby_vm_collect_usage_func_operand)
4179 (*ruby_vm_collect_usage_func_operand)(insn, n, op);
4185 vm_collect_usage_register(
int reg,
int isset)
4187 if (ruby_vm_collect_usage_func_register)
4188 (*ruby_vm_collect_usage_func_register)(reg, isset);
4193 rb_vm_empty_cc(
void)
4195 return &vm_empty_cc;
4199 rb_vm_empty_cc_for_super(
void)
4201 return &vm_empty_cc_for_super;
4206 #include "vm_call_iseq_optimized.inc"
#define RUBY_ASSERT_MESG(expr, mesg)
Asserts that the expression is truthy.
#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.
VALUE rb_define_module_under(VALUE outer, const char *name)
Defines a module under the namespace of outer.
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.
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a method.
int rb_get_kwargs(VALUE keyword_hash, const ID *table, int required, int optional, VALUE *values)
Keyword argument deconstructor.
#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 CLASS_OF
Old name of rb_class_of.
#define rb_ary_new4
Old name of rb_ary_new_from_values.
#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 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_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_ruby_verbose_ptr(void)
This is an implementation detail of ruby_verbose.
VALUE rb_cTime
Time class.
VALUE rb_cArray
Array class.
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_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.
void rb_gc_register_mark_object(VALUE object)
Inform the garbage collector that object is a live Ruby object that should not be moved.
Defines RBIMPL_HAS_BUILTIN.
VALUE rb_ary_delete_at(VALUE ary, long pos)
Destructively removes an element which resides at the specific index of the passed array.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_tmp_new(long capa)
Allocates a "temporary" array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
void rb_undef(VALUE mod, ID mid)
Inserts a method entry that hides previous method definition of the given name.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
void rb_set_end_proc(void(*func)(VALUE arg), VALUE arg)
Registers a function that shall run on process exit.
void rb_gc_mark(VALUE obj)
Marks an object.
void rb_mark_tbl_no_pin(struct st_table *tbl)
Identical to rb_mark_tbl(), except it marks objects using rb_gc_mark_movable().
void rb_memerror(void)
Triggers out-of-memory error.
void rb_gc_mark_movable(VALUE obj)
Maybe this is the only function provided for C extensions to control the pinning of objects,...
void rb_mark_tbl(struct st_table *tbl)
Identical to rb_mark_hash(), except it marks only values of the table and leave their associated keys...
void rb_gc_mark_maybe(VALUE obj)
Identical to rb_gc_mark(), except it allows the passed value be a non-object.
VALUE rb_gc_location(VALUE obj)
Finds a new "location" of an object.
void rb_gc_mark_locations(const VALUE *start, const VALUE *end)
Marks objects between the two pointers.
void rb_gc_update_tbl_refs(st_table *ptr)
Updates references inside of tables.
void rb_hash_bulk_insert(long argc, const VALUE *argv, VALUE hash)
Inserts a list of key-value pairs into a hash table at once.
void rb_hash_foreach(VALUE hash, int(*func)(VALUE key, VALUE val, VALUE arg), VALUE arg)
Iterates over a hash.
VALUE rb_hash_aref(VALUE hash, VALUE key)
Queries the given key in the given hash table.
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Inserts or replaces ("upsert"s) the objects into the given hash table.
VALUE rb_hash_dup(VALUE hash)
Duplicates a hash.
VALUE rb_hash_clear(VALUE hash)
Swipes everything out of the passed hash table.
VALUE rb_hash_new(void)
Creates a new, empty hash object.
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.
VALUE rb_str_cat_cstr(VALUE dst, const char *src)
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.
void rb_alias(VALUE klass, ID dst, ID src)
Resembles alias.
const char * rb_sourcefile(void)
Resembles __FILE__.
int rb_frame_method_id_and_class(ID *idp, VALUE *klassp)
Resembles __method__.
int rb_sourceline(void)
Resembles __LINE__.
const char * rb_id2name(ID id)
Retrieves the name mapped to the given id.
ID rb_intern(const char *name)
Finds or creates a symbol of the given name.
VALUE rb_sym2str(VALUE id)
Identical to rb_id2str(), except it takes an instance of rb_cSymbol rather than an ID.
VALUE rb_id2str(ID id)
Identical to rb_id2name(), except it returns a Ruby's String instead of C's.
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.
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.
int st_foreach(st_table *q, int_type *w, st_data_t e)
Iteration over the given table.
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.
#define RARRAY_LEN
Just another name of rb_array_len.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
#define RARRAY_AREF(a, i)
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
#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*.
static char * RSTRING_PTR(VALUE str)
Queries the contents pointer of the string.
#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.
This is the struct that holds necessary info for a struct.
struct rb_iseq_constant_body::@152 param
parameter information
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 ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
ruby_value_type
C-level type of an object.
void ruby_xfree(void *ptr)
Deallocates a storage instance.