11#include "ruby/internal/config.h"
15#ifdef HAVE_STDATOMIC_H
16 #include <stdatomic.h>
20#include "debug_counter.h"
22#include "internal/class.h"
23#include "internal/compar.h"
24#include "internal/hash.h"
25#include "internal/numeric.h"
26#include "internal/proc.h"
27#include "internal/random.h"
28#include "internal/variable.h"
29#include "internal/set_table.h"
30#include "internal/struct.h"
35#include "insns_info.inc"
37extern rb_method_definition_t *rb_method_definition_create(rb_method_type_t
type,
ID mid);
38extern void rb_method_definition_set(
const rb_method_entry_t *me, rb_method_definition_t *def,
void *opts);
39extern int rb_method_definition_eq(
const rb_method_definition_t *d1,
const rb_method_definition_t *d2);
41 int argc,
const VALUE *argv,
int priv);
48static rb_control_frame_t *vm_get_ruby_level_caller_cfp(
const rb_execution_context_t *ec,
const rb_control_frame_t *cfp);
51ruby_vm_special_exception_copy(
VALUE exc)
54 rb_obj_copy_ivar(e, exc);
58NORETURN(
static void ec_stack_overflow(rb_execution_context_t *ec,
int));
60ec_stack_overflow(rb_execution_context_t *ec,
int setup)
62 VALUE mesg = rb_ec_vm_ptr(ec)->special_exceptions[ruby_error_sysstack];
63 ec->raised_flag = RAISED_STACKOVERFLOW;
65 VALUE at = rb_ec_backtrace_object(ec);
66 mesg = ruby_vm_special_exception_copy(mesg);
71 EC_JUMP_TAG(ec, TAG_RAISE);
74NORETURN(
static void vm_stackoverflow(
void));
79 ec_stack_overflow(GET_EC(), TRUE);
83rb_ec_stack_overflow(rb_execution_context_t *ec, ruby_stack_overflow_critical_level crit)
86 rb_bug(
"system stack overflow during GC. Faulty native extension?");
88 if (crit >= rb_stack_overflow_fatal) {
89 ec->raised_flag = RAISED_STACKOVERFLOW;
90 ec->errinfo = rb_ec_vm_ptr(ec)->special_exceptions[ruby_error_stackfatal];
91 EC_JUMP_TAG(ec, TAG_RAISE);
93 ec_stack_overflow(ec, crit < rb_stack_overflow_signal);
96static inline void stack_check(rb_execution_context_t *ec);
100callable_class_p(
VALUE klass)
102#if VM_CHECK_MODE >= 2
103 if (!klass)
return FALSE;
104 switch (RB_BUILTIN_TYPE(klass)) {
125callable_method_entry_p(
const rb_callable_method_entry_t *cme)
131 VM_ASSERT(IMEMO_TYPE_P((
VALUE)cme, imemo_ment),
"imemo_type:%s", rb_imemo_name(imemo_type((
VALUE)cme)));
133 if (callable_class_p(cme->defined_class)) {
143vm_check_frame_detail(
VALUE type,
int req_block,
int req_me,
int req_cref,
VALUE specval,
VALUE cref_or_me,
int is_cframe,
const rb_iseq_t *iseq)
145 unsigned int magic = (
unsigned int)(
type & VM_FRAME_MAGIC_MASK);
146 enum imemo_type cref_or_me_type = imemo_env;
148 if (RB_TYPE_P(cref_or_me,
T_IMEMO)) {
149 cref_or_me_type = imemo_type(cref_or_me);
151 if (
type & VM_FRAME_FLAG_BMETHOD) {
155 if (req_block && (
type & VM_ENV_FLAG_LOCAL) == 0) {
156 rb_bug(
"vm_push_frame: specval (%p) should be a block_ptr on %x frame", (
void *)specval, magic);
158 if (!req_block && (
type & VM_ENV_FLAG_LOCAL) != 0) {
159 rb_bug(
"vm_push_frame: specval (%p) should not be a block_ptr on %x frame", (
void *)specval, magic);
163 if (cref_or_me_type != imemo_ment) {
164 rb_bug(
"vm_push_frame: (%s) should be method entry on %x frame", rb_obj_info(cref_or_me), magic);
168 if (req_cref && cref_or_me_type != imemo_cref) {
169 rb_bug(
"vm_push_frame: (%s) should be CREF on %x frame", rb_obj_info(cref_or_me), magic);
172 if (cref_or_me !=
Qfalse && cref_or_me_type != imemo_cref) {
173 if (((
type & VM_FRAME_FLAG_LAMBDA) || magic == VM_FRAME_MAGIC_IFUNC || magic == VM_FRAME_MAGIC_DUMMY) && (cref_or_me_type == imemo_ment)) {
177 rb_bug(
"vm_push_frame: (%s) should be false or cref on %x frame", rb_obj_info(cref_or_me), magic);
183 if (cref_or_me_type == imemo_ment) {
184 const rb_callable_method_entry_t *me = (
const rb_callable_method_entry_t *)cref_or_me;
186 if (!callable_method_entry_p(me)) {
187 rb_bug(
"vm_push_frame: ment (%s) should be callable on %x frame.", rb_obj_info(cref_or_me), magic);
191 if ((
type & VM_FRAME_MAGIC_MASK) == VM_FRAME_MAGIC_DUMMY) {
192 VM_ASSERT(iseq == NULL ||
193 RBASIC_CLASS((
VALUE)iseq) == 0 ||
194 RUBY_VM_NORMAL_ISEQ_P(iseq)
198 VM_ASSERT(is_cframe == !RUBY_VM_NORMAL_ISEQ_P(iseq));
206 const rb_iseq_t *iseq)
208 VALUE given_magic =
type & VM_FRAME_MAGIC_MASK;
211#define CHECK(magic, req_block, req_me, req_cref, is_cframe) \
213 vm_check_frame_detail(type, req_block, req_me, req_cref, \
214 specval, cref_or_me, is_cframe, iseq); \
216 switch (given_magic) {
218 CHECK(VM_FRAME_MAGIC_METHOD, TRUE, TRUE, FALSE, FALSE);
219 CHECK(VM_FRAME_MAGIC_CLASS, TRUE, FALSE, TRUE, FALSE);
220 CHECK(VM_FRAME_MAGIC_TOP, TRUE, FALSE, TRUE, FALSE);
221 CHECK(VM_FRAME_MAGIC_CFUNC, TRUE, TRUE, FALSE, TRUE);
222 CHECK(VM_FRAME_MAGIC_BLOCK, FALSE, FALSE, FALSE, FALSE);
223 CHECK(VM_FRAME_MAGIC_IFUNC, FALSE, FALSE, FALSE, TRUE);
224 CHECK(VM_FRAME_MAGIC_EVAL, FALSE, FALSE, FALSE, FALSE);
225 CHECK(VM_FRAME_MAGIC_RESCUE, FALSE, FALSE, FALSE, FALSE);
226 CHECK(VM_FRAME_MAGIC_DUMMY, TRUE, FALSE, FALSE, FALSE);
228 rb_bug(
"vm_push_frame: unknown type (%x)", (
unsigned int)given_magic);
233static VALUE vm_stack_canary;
234static bool vm_stack_canary_was_born =
false;
239previous_insn_index(
const rb_iseq_t *iseq,
const VALUE *pc)
241 unsigned int pos = 0;
242 while (pos < ISEQ_BODY(iseq)->iseq_size) {
243 int opcode = rb_vm_insn_addr2opcode((
void *)ISEQ_BODY(iseq)->iseq_encoded[pos]);
244 unsigned int next_pos = pos + insn_len(opcode);
245 if (ISEQ_BODY(iseq)->iseq_encoded + next_pos == pc) {
250 rb_bug(
"failed to find the previous insn");
254rb_vm_check_canary(
const rb_execution_context_t *ec,
VALUE *sp)
259 if (! LIKELY(vm_stack_canary_was_born)) {
262 else if ((
VALUE *)reg_cfp == ec->vm_stack + ec->vm_stack_size) {
266 else if (! (iseq = GET_ISEQ())) {
269 else if (LIKELY(sp[0] != vm_stack_canary)) {
278 const VALUE *orig = rb_iseq_original_iseq(iseq);
279 const VALUE iseqw = rb_iseqw_new(iseq);
281 const char *stri = rb_str_to_cstr(inspection);
282 const VALUE disasm = rb_iseq_disasm(iseq);
283 const char *strd = rb_str_to_cstr(disasm);
284 const ptrdiff_t pos = previous_insn_index(iseq, GET_PC());
285 const enum ruby_vminsn_type insn = (
enum ruby_vminsn_type)orig[pos];
286 const char *name = insn_name(insn);
292 "We are killing the stack canary set by %s, "
293 "at %s@pc=%"PRIdPTR
"\n"
294 "watch out the C stack trace.\n"
296 name, stri, pos, strd);
297 rb_bug(
"see above.");
299#define vm_check_canary(ec, sp) rb_vm_check_canary(ec, sp)
302#define vm_check_canary(ec, sp)
303#define vm_check_frame(a, b, c, d)
308vm_push_frame_debug_counter_inc(
315 RB_DEBUG_COUNTER_INC(frame_push);
317 if (RUBY_VM_END_CONTROL_FRAME(ec) != prev_cfp) {
318 const bool curr = VM_FRAME_RUBYFRAME_P(reg_cfp);
319 const bool prev = VM_FRAME_RUBYFRAME_P(prev_cfp);
322 RB_DEBUG_COUNTER_INC(frame_R2R);
325 RB_DEBUG_COUNTER_INC(frame_R2C);
330 RB_DEBUG_COUNTER_INC(frame_C2R);
333 RB_DEBUG_COUNTER_INC(frame_C2C);
338 switch (
type & VM_FRAME_MAGIC_MASK) {
339 case VM_FRAME_MAGIC_METHOD: RB_DEBUG_COUNTER_INC(frame_push_method);
return;
340 case VM_FRAME_MAGIC_BLOCK: RB_DEBUG_COUNTER_INC(frame_push_block);
return;
341 case VM_FRAME_MAGIC_CLASS: RB_DEBUG_COUNTER_INC(frame_push_class);
return;
342 case VM_FRAME_MAGIC_TOP: RB_DEBUG_COUNTER_INC(frame_push_top);
return;
343 case VM_FRAME_MAGIC_CFUNC: RB_DEBUG_COUNTER_INC(frame_push_cfunc);
return;
344 case VM_FRAME_MAGIC_IFUNC: RB_DEBUG_COUNTER_INC(frame_push_ifunc);
return;
345 case VM_FRAME_MAGIC_EVAL: RB_DEBUG_COUNTER_INC(frame_push_eval);
return;
346 case VM_FRAME_MAGIC_RESCUE: RB_DEBUG_COUNTER_INC(frame_push_rescue);
return;
347 case VM_FRAME_MAGIC_DUMMY: RB_DEBUG_COUNTER_INC(frame_push_dummy);
return;
350 rb_bug(
"unreachable");
353#define vm_push_frame_debug_counter_inc(ec, cfp, t)
358rb_vm_stack_canary(
void)
361 return vm_stack_canary;
367STATIC_ASSERT(VM_ENV_DATA_INDEX_ME_CREF, VM_ENV_DATA_INDEX_ME_CREF == -2);
368STATIC_ASSERT(VM_ENV_DATA_INDEX_SPECVAL, VM_ENV_DATA_INDEX_SPECVAL == -1);
369STATIC_ASSERT(VM_ENV_DATA_INDEX_FLAGS, VM_ENV_DATA_INDEX_FLAGS == -0);
372vm_push_frame(rb_execution_context_t *ec,
373 const rb_iseq_t *iseq,
383 rb_control_frame_t *
const cfp = RUBY_VM_NEXT_CONTROL_FRAME(ec->cfp);
385 vm_check_frame(
type, specval, cref_or_me, iseq);
386 VM_ASSERT(local_size >= 0);
389 CHECK_VM_STACK_OVERFLOW0(cfp, sp, local_size + stack_max);
390 vm_check_canary(ec, sp);
395 for (
int i=0; i < local_size; i++) {
422 #if defined HAVE_DECL_ATOMIC_SIGNAL_FENCE && HAVE_DECL_ATOMIC_SIGNAL_FENCE
423 atomic_signal_fence(memory_order_seq_cst);
431 vm_push_frame_debug_counter_inc(ec, cfp,
type);
435rb_vm_pop_frame_no_int(rb_execution_context_t *ec)
437 rb_control_frame_t *cfp = ec->cfp;
439 if (VMDEBUG == 2) SDR();
441 ec->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
446vm_pop_frame(rb_execution_context_t *ec, rb_control_frame_t *cfp,
const VALUE *ep)
448 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
450 if (VMDEBUG == 2) SDR();
452 RUBY_VM_CHECK_INTS(ec);
453 ec->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
455 return flags & VM_FRAME_FLAG_FINISH;
459rb_vm_pop_frame(rb_execution_context_t *ec)
461 vm_pop_frame(ec, ec->cfp, ec->cfp->ep);
466rb_vm_push_frame_fname(rb_execution_context_t *ec,
VALUE fname)
468 rb_iseq_t *rb_iseq_alloc_with_dummy_path(
VALUE fname);
469 rb_iseq_t *dmy_iseq = rb_iseq_alloc_with_dummy_path(fname);
473 VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH,
475 VM_BLOCK_HANDLER_NONE,
482 return (
VALUE)dmy_iseq;
487rb_arity_error_new(
int argc,
int min,
int max)
489 VALUE err_mess = rb_sprintf(
"wrong number of arguments (given %d, expected %d", argc, min);
497 rb_str_catf(err_mess,
"..%d", max);
504rb_error_arity(
int argc,
int min,
int max)
511NOINLINE(
static void vm_env_write_slowpath(
const VALUE *ep,
int index,
VALUE v));
514vm_env_write_slowpath(
const VALUE *ep,
int index,
VALUE v)
517 rb_gc_writebarrier_remember(VM_ENV_ENVVAL(ep));
518 VM_FORCE_WRITE(&ep[index], v);
519 VM_ENV_FLAGS_UNSET(ep, VM_ENV_FLAG_WB_REQUIRED);
520 RB_DEBUG_COUNTER_INC(lvar_set_slowpath);
525vm_env_write(
const VALUE *ep,
int index,
VALUE v)
527 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
528 if (LIKELY((flags & VM_ENV_FLAG_WB_REQUIRED) == 0)) {
529 VM_STACK_ENV_WRITE(ep, index, v);
532 vm_env_write_slowpath(ep, index, v);
537rb_vm_env_write(
const VALUE *ep,
int index,
VALUE v)
539 vm_env_write(ep, index, v);
543rb_vm_bh_to_procval(
const rb_execution_context_t *ec,
VALUE block_handler)
545 if (block_handler == VM_BLOCK_HANDLER_NONE) {
549 switch (vm_block_handler_type(block_handler)) {
550 case block_handler_type_iseq:
551 case block_handler_type_ifunc:
552 return rb_vm_make_proc(ec, VM_BH_TO_CAPT_BLOCK(block_handler),
rb_cProc);
553 case block_handler_type_symbol:
554 return rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
555 case block_handler_type_proc:
556 return VM_BH_TO_PROC(block_handler);
558 VM_UNREACHABLE(rb_vm_bh_to_procval);
567vm_svar_valid_p(
VALUE svar)
570 switch (imemo_type(svar)) {
579 rb_bug(
"vm_svar_valid_p: unknown type: %s", rb_obj_info(svar));
585lep_svar(
const rb_execution_context_t *ec,
const VALUE *lep)
589 if (lep && (ec == NULL || ec->root_lep != lep)) {
590 svar = lep[VM_ENV_DATA_INDEX_ME_CREF];
593 svar = ec->root_svar;
596 VM_ASSERT(svar ==
Qfalse || vm_svar_valid_p(svar));
602lep_svar_write(
const rb_execution_context_t *ec,
const VALUE *lep,
const struct vm_svar *svar)
604 VM_ASSERT(vm_svar_valid_p((
VALUE)svar));
606 if (lep && (ec == NULL || ec->root_lep != lep)) {
607 vm_env_write(lep, VM_ENV_DATA_INDEX_ME_CREF, (
VALUE)svar);
610 RB_OBJ_WRITE(rb_ec_thread_ptr(ec)->self, &ec->root_svar, svar);
615lep_svar_get(
const rb_execution_context_t *ec,
const VALUE *lep, rb_num_t key)
617 const struct vm_svar *svar = lep_svar(ec, lep);
622 case VM_SVAR_LASTLINE:
623 return svar->lastline;
624 case VM_SVAR_BACKREF:
625 return svar->backref;
627 const VALUE ary = svar->others;
642 struct vm_svar *svar = IMEMO_NEW(
struct vm_svar, imemo_svar, obj);
651lep_svar_set(
const rb_execution_context_t *ec,
const VALUE *lep, rb_num_t key,
VALUE val)
653 struct vm_svar *svar = lep_svar(ec, lep);
656 lep_svar_write(ec, lep, svar = svar_new((
VALUE)svar));
660 case VM_SVAR_LASTLINE:
663 case VM_SVAR_BACKREF:
667 VALUE ary = svar->others;
678vm_getspecial(
const rb_execution_context_t *ec,
const VALUE *lep, rb_num_t key, rb_num_t
type)
683 val = lep_svar_get(ec, lep, key);
686 VALUE backref = lep_svar_get(ec, lep, VM_SVAR_BACKREF);
703 rb_bug(
"unexpected back-ref");
714vm_backref_defined(
const rb_execution_context_t *ec,
const VALUE *lep, rb_num_t
type)
716 VALUE backref = lep_svar_get(ec, lep, VM_SVAR_BACKREF);
726 return rb_reg_last_defined(backref);
728 rb_bug(
"unexpected back-ref");
732 nth = (int)(
type >> 1);
737PUREFUNC(
static rb_callable_method_entry_t *check_method_entry(
VALUE obj,
int can_be_svar));
738static rb_callable_method_entry_t *
739check_method_entry(
VALUE obj,
int can_be_svar)
741 if (obj ==
Qfalse)
return NULL;
744 if (!RB_TYPE_P(obj,
T_IMEMO)) rb_bug(
"check_method_entry: unknown type: %s", rb_obj_info(obj));
747 switch (imemo_type(obj)) {
749 return (rb_callable_method_entry_t *)obj;
758 rb_bug(
"check_method_entry: svar should not be there:");
764static rb_callable_method_entry_t *
765env_method_entry_unchecked(
VALUE obj,
int can_be_svar)
767 if (obj ==
Qfalse)
return NULL;
769 switch (imemo_type(obj)) {
771 return (rb_callable_method_entry_t *)obj;
783const rb_callable_method_entry_t *
784rb_vm_frame_method_entry(
const rb_control_frame_t *cfp)
786 const VALUE *ep = cfp->ep;
787 rb_callable_method_entry_t *me;
789 while (!VM_ENV_LOCAL_P(ep)) {
790 if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL)
return me;
791 ep = VM_ENV_PREV_EP(ep);
794 return check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
797const rb_callable_method_entry_t *
798rb_vm_frame_method_entry_unchecked(
const rb_control_frame_t *cfp)
800 const VALUE *ep = cfp->ep;
801 rb_callable_method_entry_t *me;
803 while (!VM_ENV_LOCAL_P_UNCHECKED(ep)) {
804 if ((me = env_method_entry_unchecked(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL)
return me;
805 ep = VM_ENV_PREV_EP_UNCHECKED(ep);
808 return env_method_entry_unchecked(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
811static const rb_iseq_t *
812method_entry_iseqptr(
const rb_callable_method_entry_t *me)
814 switch (me->def->type) {
815 case VM_METHOD_TYPE_ISEQ:
816 return me->def->body.iseq.iseqptr;
823method_entry_cref(
const rb_callable_method_entry_t *me)
825 switch (me->def->type) {
826 case VM_METHOD_TYPE_ISEQ:
827 return me->def->body.iseq.cref;
833#if VM_CHECK_MODE == 0
834PUREFUNC(
static rb_cref_t *check_cref(
VALUE,
int));
837check_cref(
VALUE obj,
int can_be_svar)
839 if (obj ==
Qfalse)
return NULL;
842 if (!RB_TYPE_P(obj,
T_IMEMO)) rb_bug(
"check_cref: unknown type: %s", rb_obj_info(obj));
845 switch (imemo_type(obj)) {
847 return method_entry_cref((rb_callable_method_entry_t *)obj);
849 return (rb_cref_t *)obj;
856 rb_bug(
"check_method_entry: svar should not be there:");
862static inline rb_cref_t *
863vm_env_cref(
const VALUE *ep)
867 while (!VM_ENV_LOCAL_P(ep)) {
868 if ((cref = check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL)
return cref;
869 ep = VM_ENV_PREV_EP(ep);
872 return check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
876is_cref(
const VALUE v,
int can_be_svar)
879 switch (imemo_type(v)) {
892vm_env_cref_by_cref(
const VALUE *ep)
894 while (!VM_ENV_LOCAL_P(ep)) {
895 if (is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE))
return TRUE;
896 ep = VM_ENV_PREV_EP(ep);
898 return is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
902cref_replace_with_duplicated_cref_each_frame(
const VALUE *vptr,
int can_be_svar,
VALUE parent)
904 const VALUE v = *vptr;
905 rb_cref_t *cref, *new_cref;
908 switch (imemo_type(v)) {
910 cref = (rb_cref_t *)v;
911 new_cref = vm_cref_dup(cref);
916 VM_FORCE_WRITE(vptr, (
VALUE)new_cref);
918 return (rb_cref_t *)new_cref;
921 return cref_replace_with_duplicated_cref_each_frame(&((
struct vm_svar *)v)->
cref_or_me, FALSE, v);
925 rb_bug(
"cref_replace_with_duplicated_cref_each_frame: unreachable");
934vm_cref_replace_with_duplicated_cref(
const VALUE *ep)
936 if (vm_env_cref_by_cref(ep)) {
940 while (!VM_ENV_LOCAL_P(ep)) {
941 envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) :
Qfalse;
942 if ((cref = cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE, envval)) != NULL) {
945 ep = VM_ENV_PREV_EP(ep);
947 envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) :
Qfalse;
948 return cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE, envval);
951 rb_bug(
"vm_cref_dup: unreachable");
956vm_get_cref(
const VALUE *ep)
958 rb_cref_t *cref = vm_env_cref(ep);
964 rb_bug(
"vm_get_cref: unreachable");
969rb_vm_get_cref(
const VALUE *ep)
971 return vm_get_cref(ep);
975vm_ec_cref(
const rb_execution_context_t *ec)
977 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
982 return vm_get_cref(cfp->ep);
985static const rb_cref_t *
986vm_get_const_key_cref(
const VALUE *ep)
988 const rb_cref_t *cref = vm_get_cref(ep);
989 const rb_cref_t *key_cref = cref;
992 if (RCLASS_SINGLETON_P(CREF_CLASS(cref)) ||
993 RCLASS_CLONED_P(CREF_CLASS(cref)) ) {
996 cref = CREF_NEXT(cref);
1004rb_vm_rewrite_cref(rb_cref_t *cref,
VALUE old_klass,
VALUE new_klass)
1006 rb_cref_t *new_cref_head = NULL;
1007 rb_cref_t *new_cref_tail = NULL;
1009 #define ADD_NEW_CREF(new_cref) \
1010 if (new_cref_tail) { \
1011 RB_OBJ_WRITE(new_cref_tail, &new_cref_tail->next, new_cref); \
1014 new_cref_head = new_cref; \
1016 new_cref_tail = new_cref;
1019 rb_cref_t *new_cref;
1020 if (CREF_CLASS(cref) == old_klass) {
1021 new_cref = vm_cref_new_use_prev(new_klass, METHOD_VISI_UNDEF, FALSE, cref, FALSE);
1022 ADD_NEW_CREF(new_cref);
1023 return new_cref_head;
1025 new_cref = vm_cref_new_use_prev(CREF_CLASS(cref), METHOD_VISI_UNDEF, FALSE, cref, FALSE);
1026 cref = CREF_NEXT(cref);
1027 ADD_NEW_CREF(new_cref);
1033 return new_cref_head;
1037vm_cref_push(
const rb_execution_context_t *ec,
VALUE klass,
const VALUE *ep,
int pushed_by_eval,
int singleton)
1039 rb_cref_t *prev_cref = NULL;
1042 prev_cref = vm_env_cref(ep);
1045 rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, ec->cfp);
1048 prev_cref = vm_env_cref(cfp->ep);
1052 return vm_cref_new(klass, METHOD_VISI_PUBLIC, FALSE, prev_cref, pushed_by_eval, singleton);
1056vm_get_cbase(
const VALUE *ep)
1058 const rb_cref_t *cref = vm_get_cref(ep);
1060 return CREF_CLASS_FOR_DEFINITION(cref);
1064vm_get_const_base(
const VALUE *ep)
1066 const rb_cref_t *cref = vm_get_cref(ep);
1069 if (!CREF_PUSHED_BY_EVAL(cref)) {
1070 return CREF_CLASS_FOR_DEFINITION(cref);
1072 cref = CREF_NEXT(cref);
1079vm_check_if_namespace(
VALUE klass)
1082 rb_raise(
rb_eTypeError,
"%+"PRIsVALUE
" is not a class/module", klass);
1087vm_ensure_not_refinement_module(
VALUE self)
1089 if (RB_TYPE_P(self,
T_MODULE) &&
FL_TEST(self, RMODULE_IS_REFINEMENT)) {
1090 rb_warn(
"not defined at the refinement, but at the outer class/module");
1095vm_get_iclass(
const rb_control_frame_t *cfp,
VALUE klass)
1101vm_get_ev_const(rb_execution_context_t *ec,
VALUE orig_klass,
ID id,
bool allow_nil,
int is_defined)
1103 void rb_const_warn_if_deprecated(
const rb_const_entry_t *ce,
VALUE klass,
ID id);
1106 if (
NIL_P(orig_klass) && allow_nil) {
1108 const rb_cref_t *root_cref = vm_get_cref(ec->cfp->ep);
1109 const rb_cref_t *cref;
1112 while (root_cref && CREF_PUSHED_BY_EVAL(root_cref)) {
1113 root_cref = CREF_NEXT(root_cref);
1116 while (cref && CREF_NEXT(cref)) {
1117 if (CREF_PUSHED_BY_EVAL(cref)) {
1121 klass = CREF_CLASS(cref);
1123 cref = CREF_NEXT(cref);
1125 if (!
NIL_P(klass)) {
1127 rb_const_entry_t *ce;
1129 if ((ce = rb_const_lookup(klass,
id))) {
1130 rb_const_warn_if_deprecated(ce, klass,
id);
1133 if (am == klass)
break;
1135 if (is_defined)
return 1;
1136 if (rb_autoloading_value(klass,
id, &av, NULL))
return av;
1138 goto search_continue;
1145 if (UNLIKELY(!rb_ractor_main_p())) {
1146 if (!rb_ractor_shareable_p(val)) {
1147 rb_raise(rb_eRactorIsolationError,
1148 "can not access non-shareable objects in constant %"PRIsVALUE
"::%"PRIsVALUE
" by non-main ractor.",
rb_class_path(klass), rb_id2str(
id));
1159 if (root_cref && !
NIL_P(CREF_CLASS(root_cref))) {
1160 klass = vm_get_iclass(ec->cfp, CREF_CLASS(root_cref));
1174 vm_check_if_namespace(orig_klass);
1176 return rb_public_const_defined_from(orig_klass,
id);
1179 return rb_public_const_get_from(orig_klass,
id);
1185rb_vm_get_ev_const(rb_execution_context_t *ec,
VALUE orig_klass,
ID id,
VALUE allow_nil)
1187 return vm_get_ev_const(ec, orig_klass,
id, allow_nil ==
Qtrue, 0);
1191vm_get_ev_const_chain(rb_execution_context_t *ec,
const ID *segments)
1195 int allow_nil = TRUE;
1196 if (segments[0] == idNULL) {
1201 while (segments[idx]) {
1202 ID id = segments[idx++];
1203 val = vm_get_ev_const(ec, val,
id, allow_nil, 0);
1211vm_get_cvar_base(
const rb_cref_t *cref,
const rb_control_frame_t *cfp,
int top_level_raise)
1216 rb_bug(
"vm_get_cvar_base: no cref");
1219 while (CREF_NEXT(cref) &&
1220 (
NIL_P(CREF_CLASS(cref)) || RCLASS_SINGLETON_P(CREF_CLASS(cref)) ||
1221 CREF_PUSHED_BY_EVAL(cref) || CREF_SINGLETON(cref))) {
1222 cref = CREF_NEXT(cref);
1224 if (top_level_raise && !CREF_NEXT(cref)) {
1228 klass = vm_get_iclass(cfp, CREF_CLASS(cref));
1236ALWAYS_INLINE(
static void fill_ivar_cache(
const rb_iseq_t *iseq, IVC ic,
const struct rb_callcache *cc,
int is_attr, attr_index_t index, shape_id_t shape_id));
1238fill_ivar_cache(
const rb_iseq_t *iseq, IVC ic,
const struct rb_callcache *cc,
int is_attr, attr_index_t index, shape_id_t shape_id)
1241 vm_cc_attr_index_set(cc, index, shape_id);
1244 vm_ic_attr_index_set(iseq, ic, index, shape_id);
1248#define ractor_incidental_shareable_p(cond, val) \
1249 (!(cond) || rb_ractor_shareable_p(val))
1250#define ractor_object_incidental_shareable_p(obj, val) \
1251 ractor_incidental_shareable_p(rb_ractor_shareable_p(obj), val)
1255vm_getivar(
VALUE obj,
ID id,
const rb_iseq_t *iseq, IVC ic,
const struct rb_callcache *cc,
int is_attr,
VALUE default_value)
1260 return default_value;
1270 if (UNLIKELY(!rb_ractor_main_p())) {
1278 if (default_value ==
Qundef) {
1286 fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
1290 fields_obj = rb_obj_fields(obj,
id);
1294 return default_value;
1299 shape_id_t shape_id = RBASIC_SHAPE_ID_FOR_READ(fields_obj);
1300 VALUE *ivar_list = rb_imemo_fields_ptr(fields_obj);
1302 shape_id_t cached_id;
1306 vm_cc_atomic_shape_and_index(cc, &cached_id, &index);
1309 vm_ic_atomic_shape_and_index(ic, &cached_id, &index);
1312 if (LIKELY(cached_id == shape_id)) {
1315 if (index == ATTR_INDEX_NOT_SET) {
1316 return default_value;
1319 val = ivar_list[index];
1320#if USE_DEBUG_COUNTER
1321 RB_DEBUG_COUNTER_INC(ivar_get_ic_hit);
1324 RB_DEBUG_COUNTER_INC(ivar_get_obj_hit);
1330#if USE_DEBUG_COUNTER
1332 if (cached_id != INVALID_SHAPE_ID) {
1333 RB_DEBUG_COUNTER_INC(ivar_get_cc_miss_set);
1336 RB_DEBUG_COUNTER_INC(ivar_get_cc_miss_unset);
1340 if (cached_id != INVALID_SHAPE_ID) {
1341 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss_set);
1344 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss_unset);
1347 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss);
1350 RB_DEBUG_COUNTER_INC(ivar_get_obj_miss);
1354 if (UNLIKELY(rb_shape_too_complex_p(shape_id))) {
1355 st_table *table = (st_table *)ivar_list;
1358 RUBY_ASSERT(table == rb_imemo_fields_complex_tbl(fields_obj));
1360 if (!st_lookup(table,
id, &val)) {
1361 val = default_value;
1365 shape_id_t previous_cached_id = cached_id;
1366 if (rb_shape_get_iv_index_with_hint(shape_id,
id, &index, &cached_id)) {
1369 if (cached_id != previous_cached_id) {
1370 fill_ivar_cache(iseq, ic, cc, is_attr, index, cached_id);
1373 if (index == ATTR_INDEX_NOT_SET) {
1374 val = default_value;
1378 val = ivar_list[index];
1384 vm_cc_attr_index_initialize(cc, shape_id);
1387 vm_ic_attr_index_initialize(ic, shape_id);
1390 val = default_value;
1395 if (!UNDEF_P(default_value)) {
1403 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss);
1406 return rb_attr_get(obj,
id);
1414populate_cache(attr_index_t index, shape_id_t next_shape_id,
ID id,
const rb_iseq_t *iseq, IVC ic,
const struct rb_callcache *cc,
bool is_attr)
1416 RUBY_ASSERT(!rb_shape_too_complex_p(next_shape_id));
1420 vm_cc_attr_index_set(cc, index, next_shape_id);
1423 vm_ic_attr_index_set(iseq, ic, index, next_shape_id);
1427ALWAYS_INLINE(
static VALUE vm_setivar_slowpath(
VALUE obj,
ID id,
VALUE val,
const rb_iseq_t *iseq, IVC ic,
const struct rb_callcache *cc,
int is_attr));
1428NOINLINE(
static VALUE vm_setivar_slowpath_ivar(
VALUE obj,
ID id,
VALUE val,
const rb_iseq_t *iseq, IVC ic));
1432vm_setivar_slowpath(
VALUE obj,
ID id,
VALUE val,
const rb_iseq_t *iseq, IVC ic,
const struct rb_callcache *cc,
int is_attr)
1435 RB_DEBUG_COUNTER_INC(ivar_set_ic_miss);
1437 rb_check_frozen(obj);
1439 attr_index_t index = rb_ivar_set_index(obj,
id, val);
1440 shape_id_t next_shape_id = RBASIC_SHAPE_ID(obj);
1442 if (!rb_shape_too_complex_p(next_shape_id)) {
1443 populate_cache(index, next_shape_id,
id, iseq, ic, cc, is_attr);
1446 RB_DEBUG_COUNTER_INC(ivar_set_obj_miss);
1454vm_setivar_slowpath_ivar(
VALUE obj,
ID id,
VALUE val,
const rb_iseq_t *iseq, IVC ic)
1456 return vm_setivar_slowpath(obj,
id, val, iseq, ic, NULL,
false);
1462 return vm_setivar_slowpath(obj,
id, val, NULL, NULL, cc,
true);
1465NOINLINE(
static VALUE vm_setivar_class(
VALUE obj,
ID id,
VALUE val, shape_id_t dest_shape_id, attr_index_t index));
1467vm_setivar_class(
VALUE obj,
ID id,
VALUE val, shape_id_t dest_shape_id, attr_index_t index)
1469 if (UNLIKELY(!rb_ractor_main_p())) {
1473 VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
1474 if (UNLIKELY(!fields_obj)) {
1478 shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);
1481 if (shape_id == dest_shape_id) {
1482 RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);
1484 else if (dest_shape_id != INVALID_SHAPE_ID) {
1485 if (RSHAPE_DIRECT_CHILD_P(shape_id, dest_shape_id) && RSHAPE_EDGE_NAME(dest_shape_id) ==
id && RSHAPE_CAPACITY(shape_id) == RSHAPE_CAPACITY(dest_shape_id)) {
1486 RUBY_ASSERT(index < RSHAPE_CAPACITY(dest_shape_id));
1496 RB_OBJ_WRITE(fields_obj, &rb_imemo_fields_ptr(fields_obj)[index], val);
1498 if (shape_id != dest_shape_id) {
1499 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1500 RBASIC_SET_SHAPE_ID(fields_obj, dest_shape_id);
1503 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1508NOINLINE(
static VALUE vm_setivar_default(
VALUE obj,
ID id,
VALUE val, shape_id_t dest_shape_id, attr_index_t index));
1510vm_setivar_default(
VALUE obj,
ID id,
VALUE val, shape_id_t dest_shape_id, attr_index_t index)
1512 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1515 if (shape_id == dest_shape_id) {
1516 RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);
1518 else if (dest_shape_id != INVALID_SHAPE_ID) {
1519 if (RSHAPE_DIRECT_CHILD_P(shape_id, dest_shape_id) && RSHAPE_EDGE_NAME(dest_shape_id) ==
id && RSHAPE_CAPACITY(shape_id) == RSHAPE_CAPACITY(dest_shape_id)) {
1520 RUBY_ASSERT(index < RSHAPE_CAPACITY(dest_shape_id));
1530 VALUE fields_obj = rb_obj_fields(obj,
id);
1532 RB_OBJ_WRITE(fields_obj, &rb_imemo_fields_ptr(fields_obj)[index], val);
1534 if (shape_id != dest_shape_id) {
1535 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1536 RBASIC_SET_SHAPE_ID(fields_obj, dest_shape_id);
1539 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1545vm_setivar(
VALUE obj,
ID id,
VALUE val, shape_id_t dest_shape_id, attr_index_t index)
1553 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1554 RUBY_ASSERT(dest_shape_id == INVALID_SHAPE_ID || !rb_shape_too_complex_p(dest_shape_id));
1556 if (LIKELY(shape_id == dest_shape_id)) {
1557 RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);
1558 VM_ASSERT(!rb_ractor_shareable_p(obj));
1560 else if (dest_shape_id != INVALID_SHAPE_ID) {
1561 if (RSHAPE_DIRECT_CHILD_P(shape_id, dest_shape_id) && RSHAPE_EDGE_NAME(dest_shape_id) ==
id && RSHAPE_CAPACITY(shape_id) == RSHAPE_CAPACITY(dest_shape_id)) {
1562 RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);
1564 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1566 RUBY_ASSERT(index < RSHAPE_CAPACITY(dest_shape_id));
1581 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1582 RB_DEBUG_COUNTER_INC(ivar_set_obj_hit);
1588 RB_DEBUG_COUNTER_INC(ivar_set_ic_miss_noobject);
1598update_classvariable_cache(
const rb_iseq_t *iseq,
VALUE klass,
ID id,
const rb_cref_t * cref, ICVARC ic)
1600 VALUE defined_class = 0;
1603 if (RB_TYPE_P(defined_class,
T_ICLASS)) {
1604 defined_class =
RBASIC(defined_class)->klass;
1607 VALUE rb_cvc_tbl = RCLASS_CVC_TBL(defined_class);
1609 rb_bug(
"the cvc table should be set");
1613 if (!rb_marked_id_table_lookup(rb_cvc_tbl,
id, &ent_data)) {
1614 rb_bug(
"should have cvar cache entry");
1619 ent->global_cvar_state = GET_GLOBAL_CVAR_STATE();
1629vm_getclassvariable(
const rb_iseq_t *iseq,
const rb_control_frame_t *reg_cfp,
ID id, ICVARC ic)
1631 const rb_cref_t *cref;
1632 cref = vm_get_cref(GET_EP());
1634 if (ic->entry && ic->entry->global_cvar_state == GET_GLOBAL_CVAR_STATE() && ic->entry->cref == cref && LIKELY(rb_ractor_main_p())) {
1635 RB_DEBUG_COUNTER_INC(cvar_read_inline_hit);
1637 VALUE v = rb_ivar_lookup(ic->entry->class_value,
id,
Qundef);
1643 VALUE klass = vm_get_cvar_base(cref, reg_cfp, 1);
1645 return update_classvariable_cache(iseq, klass,
id, cref, ic);
1649rb_vm_getclassvariable(
const rb_iseq_t *iseq,
const rb_control_frame_t *cfp,
ID id, ICVARC ic)
1651 return vm_getclassvariable(iseq, cfp,
id, ic);
1655vm_setclassvariable(
const rb_iseq_t *iseq,
const rb_control_frame_t *reg_cfp,
ID id,
VALUE val, ICVARC ic)
1657 const rb_cref_t *cref;
1658 cref = vm_get_cref(GET_EP());
1660 if (ic->entry && ic->entry->global_cvar_state == GET_GLOBAL_CVAR_STATE() && ic->entry->cref == cref && LIKELY(rb_ractor_main_p())) {
1661 RB_DEBUG_COUNTER_INC(cvar_write_inline_hit);
1663 rb_class_ivar_set(ic->entry->class_value,
id, val);
1667 VALUE klass = vm_get_cvar_base(cref, reg_cfp, 1);
1671 update_classvariable_cache(iseq, klass,
id, cref, ic);
1675rb_vm_setclassvariable(
const rb_iseq_t *iseq,
const rb_control_frame_t *cfp,
ID id,
VALUE val, ICVARC ic)
1677 vm_setclassvariable(iseq, cfp,
id, val, ic);
1680ALWAYS_INLINE(
static VALUE vm_getinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id, IVC ic));
1682vm_getinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id, IVC ic)
1684 return vm_getivar(obj,
id, iseq, ic, NULL, FALSE,
Qnil);
1688vm_setinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id,
VALUE val, IVC ic)
1690 if (RB_SPECIAL_CONST_P(obj)) {
1695 shape_id_t dest_shape_id;
1697 vm_ic_atomic_shape_and_index(ic, &dest_shape_id, &index);
1699 if (UNLIKELY(UNDEF_P(vm_setivar(obj,
id, val, dest_shape_id, index)))) {
1705 if (!UNDEF_P(vm_setivar_class(obj,
id, val, dest_shape_id, index))) {
1710 if (!UNDEF_P(vm_setivar_default(obj,
id, val, dest_shape_id, index))) {
1714 vm_setivar_slowpath_ivar(obj,
id, val, iseq, ic);
1719rb_vm_setinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id,
VALUE val, IVC ic)
1721 vm_setinstancevariable(iseq, obj,
id, val, ic);
1725rb_vm_getinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id, IVC ic)
1727 return vm_getinstancevariable(iseq, obj,
id, ic);
1731vm_throw_continue(
const rb_execution_context_t *ec,
VALUE err)
1736 ec->tag->state = RUBY_TAG_FATAL;
1739 ec->tag->state = TAG_THROW;
1741 else if (THROW_DATA_P(err)) {
1742 ec->tag->state = THROW_DATA_STATE((
struct vm_throw_data *)err);
1745 ec->tag->state = TAG_RAISE;
1751vm_throw_start(
const rb_execution_context_t *ec, rb_control_frame_t *
const reg_cfp,
enum ruby_tag_type state,
1752 const int flag,
const VALUE throwobj)
1754 const rb_control_frame_t *escape_cfp = NULL;
1755 const rb_control_frame_t *
const eocfp = RUBY_VM_END_CONTROL_FRAME(ec);
1760 else if (state == TAG_BREAK) {
1762 const VALUE *ep = GET_EP();
1763 const rb_iseq_t *base_iseq = GET_ISEQ();
1764 escape_cfp = reg_cfp;
1766 while (ISEQ_BODY(base_iseq)->
type != ISEQ_TYPE_BLOCK) {
1767 if (ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_CLASS) {
1768 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1769 ep = escape_cfp->ep;
1770 base_iseq = escape_cfp->iseq;
1773 ep = VM_ENV_PREV_EP(ep);
1774 base_iseq = ISEQ_BODY(base_iseq)->parent_iseq;
1775 escape_cfp = rb_vm_search_cf_from_ep(ec, escape_cfp, ep);
1776 VM_ASSERT(escape_cfp->iseq == base_iseq);
1780 if (VM_FRAME_LAMBDA_P(escape_cfp)) {
1786 ep = VM_ENV_PREV_EP(ep);
1788 while (escape_cfp < eocfp) {
1789 if (escape_cfp->ep == ep) {
1790 const rb_iseq_t *
const iseq = escape_cfp->iseq;
1791 const VALUE epc = escape_cfp->pc - ISEQ_BODY(iseq)->iseq_encoded;
1796 for (i=0; i < ct->size; i++) {
1798 UNALIGNED_MEMBER_PTR(ct, entries[i]);
1800 if (entry->type == CATCH_TYPE_BREAK &&
1801 entry->iseq == base_iseq &&
1802 entry->start < epc && entry->end >= epc) {
1803 if (entry->cont == epc) {
1812 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1817 rb_vm_localjump_error(
"break from proc-closure", throwobj, TAG_BREAK);
1820 else if (state == TAG_RETRY) {
1821 const VALUE *ep = VM_ENV_PREV_EP(GET_EP());
1823 escape_cfp = rb_vm_search_cf_from_ep(ec, reg_cfp, ep);
1825 else if (state == TAG_RETURN) {
1826 const VALUE *current_ep = GET_EP();
1827 const VALUE *target_ep = NULL, *target_lep, *ep = current_ep;
1828 int in_class_frame = 0;
1830 escape_cfp = reg_cfp;
1833 while (!VM_ENV_LOCAL_P(ep)) {
1834 if (VM_ENV_FLAGS(ep, VM_FRAME_FLAG_LAMBDA) && target_ep == NULL) {
1837 ep = VM_ENV_PREV_EP(ep);
1841 while (escape_cfp < eocfp) {
1842 const VALUE *lep = VM_CF_LEP(escape_cfp);
1848 if (lep == target_lep &&
1849 VM_FRAME_RUBYFRAME_P(escape_cfp) &&
1850 ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_CLASS) {
1855 if (lep == target_lep) {
1856 if (VM_FRAME_LAMBDA_P(escape_cfp)) {
1858 if (in_class_frame) {
1863 const VALUE *tep = current_ep;
1865 while (target_lep != tep) {
1866 if (escape_cfp->ep == tep) {
1868 if (tep == target_ep) {
1872 goto unexpected_return;
1875 tep = VM_ENV_PREV_EP(tep);
1879 else if (VM_FRAME_RUBYFRAME_P(escape_cfp)) {
1880 switch (ISEQ_BODY(escape_cfp->iseq)->type) {
1882 case ISEQ_TYPE_MAIN:
1884 if (in_class_frame)
goto unexpected_return;
1885 if (target_ep == NULL) {
1889 goto unexpected_return;
1893 case ISEQ_TYPE_EVAL: {
1894 const rb_iseq_t *is = escape_cfp->iseq;
1895 enum rb_iseq_type t = ISEQ_BODY(is)->type;
1896 while (t == ISEQ_TYPE_RESCUE || t == ISEQ_TYPE_ENSURE || t == ISEQ_TYPE_EVAL) {
1897 if (!(is = ISEQ_BODY(is)->parent_iseq))
break;
1898 t = ISEQ_BODY(is)->type;
1900 toplevel = t == ISEQ_TYPE_TOP || t == ISEQ_TYPE_MAIN;
1903 case ISEQ_TYPE_CLASS:
1912 if (escape_cfp->ep == target_lep && ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_METHOD) {
1913 if (target_ep == NULL) {
1917 goto unexpected_return;
1921 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1924 rb_vm_localjump_error(
"unexpected return", throwobj, TAG_RETURN);
1930 rb_bug(
"isns(throw): unsupported throw type");
1933 ec->tag->state = state;
1934 return (
VALUE)THROW_DATA_NEW(throwobj, escape_cfp, state);
1938vm_throw(
const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
1939 rb_num_t throw_state,
VALUE throwobj)
1941 const int state = (int)(throw_state & VM_THROW_STATE_MASK);
1942 const int flag = (int)(throw_state & VM_THROW_NO_ESCAPE_FLAG);
1945 return vm_throw_start(ec, reg_cfp, state, flag, throwobj);
1948 return vm_throw_continue(ec, throwobj);
1953rb_vm_throw(
const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t throw_state,
VALUE throwobj)
1955 return vm_throw(ec, reg_cfp, throw_state, throwobj);
1961 int is_splat = flag & 0x01;
1964 const VALUE obj = ary;
1976 if (num + is_splat == 0) {
1979 else if (flag & 0x02) {
1984 for (i = 0; i < num -
len; i++) {
1989 for (j = 0; i < num; i++, j++) {
2011 for (; i < num -
len; i++) {
2015 for (rb_num_t j = 0; i < num; i++, j++) {
2016 *cfp->sp++ =
ptr[
len - j - 1];
2020 for (rb_num_t j = 0; j < num; j++) {
2021 *cfp->sp++ =
ptr[num - j - 1];
2029static VALUE vm_call_general(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling);
2034vm_ccs_create(
VALUE klass,
VALUE cc_tbl,
ID mid,
const rb_callable_method_entry_t *cme)
2036 int initial_capa = 2;
2038#if VM_CHECK_MODE > 0
2039 ccs->debug_sig = ~(
VALUE)ccs;
2041 ccs->capa = initial_capa;
2044 METHOD_ENTRY_CACHED_SET((rb_callable_method_entry_t *)cme);
2046 rb_managed_id_table_insert(cc_tbl, mid, (
VALUE)ccs);
2054 if (! vm_cc_markable(cc)) {
2058 if (UNLIKELY(ccs->len == ccs->capa)) {
2061 ccs = ruby_xrealloc(ccs, vm_ccs_alloc_size(ccs->capa));
2062#if VM_CHECK_MODE > 0
2063 ccs->debug_sig = ~(
VALUE)ccs;
2066 rb_managed_id_table_insert(cc_tbl, mid, (
VALUE)ccs);
2068 VM_ASSERT(ccs->len < ccs->capa);
2071 const int pos = ccs->len++;
2072 ccs->entries[pos].argc = vm_ci_argc(ci);
2073 ccs->entries[pos].flag = (
unsigned short)vm_ci_flag(ci);
2074 ccs->entries[pos].kw_len = (
unsigned short)(kwarg ? kwarg->keyword_len : 0);
2077 if (RB_DEBUG_COUNTER_SETMAX(ccs_maxlen, ccs->len)) {
2083#if VM_CHECK_MODE > 0
2087 ruby_debug_printf(
"ccs:%p (%d,%d)\n", (
void *)ccs, ccs->len, ccs->capa);
2088 for (
int i=0; i<ccs->len; i++) {
2089 ruby_debug_printf(
"CCS CI ID:flag:%x argc:%u kw_len:%u\n",
2090 ccs->entries[i].flag,
2091 ccs->entries[i].argc,
2092 ccs->entries[i].kw_len);
2093 rp(ccs->entries[i].cc);
2100 VM_ASSERT(vm_ccs_p(ccs));
2101 VM_ASSERT(ccs->len <= ccs->capa);
2103 for (
int i=0; i<ccs->len; i++) {
2106 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
2107 VM_ASSERT(vm_cc_class_check(cc, klass));
2108 VM_ASSERT(vm_cc_check_cme(cc, ccs->cme));
2109 VM_ASSERT(!vm_cc_super_p(cc));
2110 VM_ASSERT(!vm_cc_refinement_p(cc));
2116const rb_callable_method_entry_t *rb_check_overloaded_cme(
const rb_callable_method_entry_t *cme,
const struct rb_callinfo *
const ci);
2121 ASSERT_vm_locking();
2123 if (rb_multi_ractor_p()) {
2124 if (RCLASS_WRITABLE_CC_TBL(klass) != cc_tbl) {
2131 rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj);
2134 if (!ccs || !METHOD_ENTRY_INVALIDATED(ccs->cme)) {
2139 VALUE new_table = rb_vm_cc_table_dup(cc_tbl);
2140 rb_vm_cc_table_delete(new_table, mid);
2141 RB_OBJ_ATOMIC_WRITE(klass, &RCLASS_WRITABLE_CC_TBL(klass), new_table);
2144 rb_vm_cc_table_delete(cc_tbl, mid);
2151 ASSERT_vm_locking();
2153 RB_DEBUG_COUNTER_INC(cc_not_found_in_ccs);
2155 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, mid);
2157 VM_ASSERT(cme == NULL || IMEMO_TYPE_P(cme, imemo_ment));
2161 VM_ASSERT(vm_cc_cme(&vm_empty_cc) == NULL);
2162 return &vm_empty_cc;
2165 VALUE cc_tbl = RCLASS_WRITABLE_CC_TBL(klass);
2166 const VALUE original_cc_table = cc_tbl;
2169 cc_tbl = rb_vm_cc_table_create(1);
2171 else if (rb_multi_ractor_p()) {
2172 cc_tbl = rb_vm_cc_table_dup(cc_tbl);
2175 VM_ASSERT(cme == rb_callable_method_entry(klass, mid));
2184 if (UNLIKELY(rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj))) {
2189 ccs = vm_ccs_create(klass, cc_tbl, mid, cme);
2193 cme = rb_check_overloaded_cme(cme, ci);
2195 const struct rb_callcache *cc = vm_cc_new(klass, cme, vm_call_general, cc_type_normal);
2196 vm_ccs_push(cc_tbl, mid, ccs, ci, cc);
2198 VM_ASSERT(vm_cc_cme(cc) != NULL);
2199 VM_ASSERT(cme->called_id == mid);
2200 VM_ASSERT(vm_cc_cme(cc)->called_id == mid);
2202 if (original_cc_table != cc_tbl) {
2203 RB_OBJ_ATOMIC_WRITE(klass, &RCLASS_WRITABLE_CC_TBL(klass), cc_tbl);
2215 cc_tbl = RUBY_ATOMIC_VALUE_LOAD(RCLASS_WRITABLE_CC_TBL(klass));
2223 if (rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj)) {
2225 const int ccs_len = ccs->len;
2227 if (UNLIKELY(METHOD_ENTRY_INVALIDATED(ccs->cme))) {
2229 vm_evict_cc(klass, cc_tbl, mid);
2234 VM_ASSERT(vm_ccs_verify(ccs, mid, klass));
2243 unsigned int argc = vm_ci_argc(ci);
2244 unsigned int flag = vm_ci_flag(ci);
2245 unsigned int kw_len = kwarg ? kwarg->keyword_len : 0;
2247 for (
int i=0; i<ccs_len; i++) {
2248 unsigned int ccs_ci_argc = ccs->entries[i].argc;
2249 unsigned int ccs_ci_flag = ccs->entries[i].flag;
2250 unsigned int ccs_ci_kw_len = ccs->entries[i].kw_len;
2251 const struct rb_callcache *ccs_cc = ccs->entries[i].cc;
2253 VM_ASSERT(IMEMO_TYPE_P(ccs_cc, imemo_callcache));
2255 if (ccs_ci_argc == argc && ccs_ci_flag == flag && ccs_ci_kw_len == kw_len) {
2256 RB_DEBUG_COUNTER_INC(cc_found_in_ccs);
2258 VM_ASSERT(vm_cc_cme(ccs_cc)->called_id == mid);
2259 VM_ASSERT(ccs_cc->klass == klass);
2260 VM_ASSERT(!METHOD_ENTRY_INVALIDATED(vm_cc_cme(ccs_cc)));
2276 const ID mid = vm_ci_mid(ci);
2278 const struct rb_callcache *cc = vm_lookup_cc(klass, ci, mid);
2284 if (rb_multi_ractor_p()) {
2287 cc = vm_lookup_cc(klass, ci, mid);
2291 cc = vm_populate_cc(klass, ci, mid);
2305 cc = vm_search_cc(klass, ci);
2308 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
2309 VM_ASSERT(cc == vm_cc_empty() || cc->klass == klass);
2310 VM_ASSERT(cc == vm_cc_empty() || callable_method_entry_p(vm_cc_cme(cc)));
2311 VM_ASSERT(cc == vm_cc_empty() || !METHOD_ENTRY_INVALIDATED(vm_cc_cme(cc)));
2312 VM_ASSERT(cc == vm_cc_empty() || vm_cc_cme(cc)->called_id == vm_ci_mid(ci));
2320#if USE_DEBUG_COUNTER
2324 const struct rb_callcache *cc = rb_vm_search_method_slowpath(cd->ci, klass);
2326#if OPT_INLINE_METHOD_CACHE
2330 if (cd_owner && cc != empty_cc) {
2334#if USE_DEBUG_COUNTER
2335 if (!old_cc || old_cc == empty_cc) {
2337 RB_DEBUG_COUNTER_INC(mc_inline_miss_empty);
2339 else if (old_cc == cc) {
2340 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_cc);
2342 else if (vm_cc_cme(old_cc) == vm_cc_cme(cc)) {
2343 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_cme);
2345 else if (vm_cc_cme(old_cc) && vm_cc_cme(cc) &&
2346 vm_cc_cme(old_cc)->def == vm_cc_cme(cc)->def) {
2347 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_def);
2350 RB_DEBUG_COUNTER_INC(mc_inline_miss_diff);
2355 VM_ASSERT(vm_cc_cme(cc) == NULL ||
2356 vm_cc_cme(cc)->called_id == vm_ci_mid(cd->ci));
2369#if OPT_INLINE_METHOD_CACHE
2370 if (LIKELY(vm_cc_class_check(cc, klass))) {
2371 if (LIKELY(!METHOD_ENTRY_INVALIDATED(vm_cc_cme(cc)))) {
2372 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
2373 RB_DEBUG_COUNTER_INC(mc_inline_hit);
2374 VM_ASSERT(vm_cc_cme(cc) == NULL ||
2375 (vm_ci_flag(cd->ci) & VM_CALL_SUPER) ||
2376 vm_cc_cme(cc)->called_id == vm_ci_mid(cd->ci));
2380 RB_DEBUG_COUNTER_INC(mc_inline_miss_invalidated);
2383 RB_DEBUG_COUNTER_INC(mc_inline_miss_klass);
2387 return vm_search_method_slowpath0(cd_owner, cd, klass);
2394 VM_ASSERT(klass !=
Qfalse);
2397 const struct rb_callcache *cc = vm_search_method_fastpath(cd_owner, cd, klass);
2398 return vm_cc_cme(cc);
2404 return vm_search_method(cd_owner, cd, recv);
2407#if __has_attribute(transparent_union)
2420 VALUE (*f10)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2421 VALUE (*f11)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2422 VALUE (*f12)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2423 VALUE (*f13)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2424 VALUE (*f14)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2425 VALUE (*f15)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2428# define make_cfunc_type(f) (cfunc_type){.anyargs = (VALUE (*)(ANYARGS))(f)}
2431# define make_cfunc_type(f) (cfunc_type)(f)
2435check_cfunc(
const rb_callable_method_entry_t *me, cfunc_type func)
2441 VM_ASSERT(IMEMO_TYPE_P(me, imemo_ment));
2442 VM_ASSERT(callable_method_entry_p(me));
2444 if (me->def->type != VM_METHOD_TYPE_CFUNC) {
2448#if __has_attribute(transparent_union)
2449 return me->def->body.cfunc.func == func.anyargs;
2451 return me->def->body.cfunc.func == func;
2458check_method_basic_definition(
const rb_callable_method_entry_t *me)
2460 return me && METHOD_ENTRY_BASIC(me);
2464vm_method_cfunc_is(
const rb_iseq_t *iseq, CALL_DATA cd,
VALUE recv, cfunc_type func)
2466 VM_ASSERT(iseq != NULL);
2468 return check_cfunc(cme, func);
2472rb_zjit_cme_is_cfunc(
const rb_callable_method_entry_t *me,
const cfunc_type func)
2474 return check_cfunc(me, func);
2478rb_vm_method_cfunc_is(
const rb_iseq_t *iseq, CALL_DATA cd,
VALUE recv, cfunc_type func)
2480 return vm_method_cfunc_is(iseq, cd, recv, func);
2483#define check_cfunc(me, func) check_cfunc(me, make_cfunc_type(func))
2484#define vm_method_cfunc_is(iseq, cd, recv, func) vm_method_cfunc_is(iseq, cd, recv, make_cfunc_type(func))
2486#define EQ_UNREDEFINED_P(t) BASIC_OP_UNREDEFINED_P(BOP_EQ, t##_REDEFINED_OP_FLAG)
2518opt_equality_specialized(
VALUE recv,
VALUE obj)
2520 if (FIXNUM_2_P(recv, obj) && EQ_UNREDEFINED_P(INTEGER)) {
2521 goto compare_by_identity;
2523 else if (FLONUM_2_P(recv, obj) && EQ_UNREDEFINED_P(FLOAT)) {
2524 goto compare_by_identity;
2527 goto compare_by_identity;
2532 else if (RBASIC_CLASS(recv) ==
rb_cFloat && RB_FLOAT_TYPE_P(obj) && EQ_UNREDEFINED_P(FLOAT)) {
2536 return RBOOL(a == b);
2538 else if (RBASIC_CLASS(recv) ==
rb_cString && EQ_UNREDEFINED_P(STRING)) {
2542 else if (RB_TYPE_P(obj,
T_STRING)) {
2543 return rb_str_eql_internal(obj, recv);
2548 compare_by_identity:
2549 return RBOOL(recv == obj);
2553opt_equality(
const rb_iseq_t *cd_owner,
VALUE recv,
VALUE obj, CALL_DATA cd)
2555 VM_ASSERT(cd_owner != NULL);
2557 VALUE val = opt_equality_specialized(recv, obj);
2558 if (!UNDEF_P(val))
return val;
2560 if (!vm_method_cfunc_is(cd_owner, cd, recv, rb_obj_equal)) {
2564 return RBOOL(recv == obj);
2568#undef EQ_UNREDEFINED_P
2571NOINLINE(
static VALUE opt_equality_by_mid_slowpath(
VALUE recv,
VALUE obj,
ID mid));
2574opt_equality_by_mid_slowpath(
VALUE recv,
VALUE obj,
ID mid)
2576 const struct rb_callcache *cc = gccct_method_search(GET_EC(), recv, mid, &VM_CI_ON_STACK(mid, 0, 1, NULL));
2578 if (cc && check_cfunc(vm_cc_cme(cc), rb_obj_equal)) {
2579 return RBOOL(recv == obj);
2589 VALUE val = opt_equality_specialized(recv, obj);
2590 if (!UNDEF_P(val)) {
2594 return opt_equality_by_mid_slowpath(recv, obj, mid);
2601 return opt_equality_by_mid(obj1, obj2, idEq);
2607 return opt_equality_by_mid(obj1, obj2, idEqlP);
2610extern VALUE rb_vm_call0(rb_execution_context_t *ec,
VALUE,
ID,
int,
const VALUE*,
const rb_callable_method_entry_t *,
int kw_splat);
2611extern VALUE rb_vm_call_with_refinements(rb_execution_context_t *,
VALUE,
ID,
int,
const VALUE *,
int);
2614check_match(rb_execution_context_t *ec,
VALUE pattern,
VALUE target,
enum vm_check_match_type
type)
2617 case VM_CHECKMATCH_TYPE_WHEN:
2619 case VM_CHECKMATCH_TYPE_RESCUE:
2621 rb_raise(
rb_eTypeError,
"class or module required for rescue clause");
2624 case VM_CHECKMATCH_TYPE_CASE: {
2625 return rb_vm_call_with_refinements(ec, pattern, idEqq, 1, &target,
RB_NO_KEYWORDS);
2628 rb_bug(
"check_match: unreachable");
2634double_cmp_lt(
double a,
double b)
2636 return RBOOL(a < b);
2640double_cmp_le(
double a,
double b)
2642 return RBOOL(a <= b);
2646double_cmp_gt(
double a,
double b)
2648 return RBOOL(a > b);
2652double_cmp_ge(
double a,
double b)
2654 return RBOOL(a >= b);
2658static inline VALUE *
2659vm_base_ptr(
const rb_control_frame_t *cfp)
2661 const rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
2663 if (cfp->iseq && VM_FRAME_RUBYFRAME_P(cfp)) {
2664 VALUE *bp = prev_cfp->sp + ISEQ_BODY(cfp->iseq)->local_table_size + VM_ENV_DATA_SIZE;
2666 if (ISEQ_BODY(cfp->iseq)->param.flags.forwardable && VM_ENV_LOCAL_P(cfp->ep)) {
2667 int lts = ISEQ_BODY(cfp->iseq)->local_table_size;
2668 int params = ISEQ_BODY(cfp->iseq)->param.size;
2670 CALL_INFO ci = (CALL_INFO)cfp->ep[-(VM_ENV_DATA_SIZE + (lts - params))];
2671 bp += vm_ci_argc(ci);
2674 if (ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_METHOD || VM_FRAME_BMETHOD_P(cfp)) {
2678#if VM_DEBUG_BP_CHECK
2679 if (bp != cfp->bp_check) {
2680 ruby_debug_printf(
"bp_check: %ld, bp: %ld\n",
2681 (
long)(cfp->bp_check - GET_EC()->vm_stack),
2682 (
long)(bp - GET_EC()->vm_stack));
2683 rb_bug(
"vm_base_ptr: unreachable");
2694rb_vm_base_ptr(
const rb_control_frame_t *cfp)
2696 return vm_base_ptr(cfp);
2703static inline VALUE vm_call_iseq_setup_2(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
int opt_pc,
int param_size,
int local_size);
2704ALWAYS_INLINE(
static VALUE vm_call_iseq_setup_normal(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
const rb_callable_method_entry_t *me,
int opt_pc,
int param_size,
int local_size));
2705static inline VALUE vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
int opt_pc);
2706static VALUE vm_call_super_method(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling);
2707static VALUE vm_call_method_nome(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling);
2708static VALUE vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling);
2709static inline VALUE vm_call_method(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling);
2711static vm_call_handler vm_call_iseq_setup_func(
const struct rb_callinfo *ci,
const int param_size,
const int local_size);
2714vm_call_iseq_setup_tailcall_0start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
2716 RB_DEBUG_COUNTER_INC(ccf_iseq_setup_tailcall_0start);
2718 return vm_call_iseq_setup_tailcall(ec, cfp, calling, 0);
2722vm_call_iseq_setup_normal_0start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
2724 RB_DEBUG_COUNTER_INC(ccf_iseq_setup_0start);
2727 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
2728 int param = ISEQ_BODY(iseq)->param.size;
2729 int local = ISEQ_BODY(iseq)->local_table_size;
2730 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
2734rb_simple_iseq_p(
const rb_iseq_t *iseq)
2736 return ISEQ_BODY(iseq)->param.flags.has_opt == FALSE &&
2737 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2738 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2739 ISEQ_BODY(iseq)->param.flags.has_kw == FALSE &&
2740 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2741 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg == FALSE &&
2742 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2743 ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
2747rb_iseq_only_optparam_p(
const rb_iseq_t *iseq)
2749 return ISEQ_BODY(iseq)->param.flags.has_opt == TRUE &&
2750 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2751 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2752 ISEQ_BODY(iseq)->param.flags.has_kw == FALSE &&
2753 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2754 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg == FALSE &&
2755 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2756 ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
2760rb_iseq_only_kwparam_p(
const rb_iseq_t *iseq)
2762 return ISEQ_BODY(iseq)->param.flags.has_opt == FALSE &&
2763 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2764 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2765 ISEQ_BODY(iseq)->param.flags.has_kw == TRUE &&
2766 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2767 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2768 ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
2771#define ALLOW_HEAP_ARGV (-2)
2772#define ALLOW_HEAP_ARGV_KEEP_KWSPLAT (-3)
2775vm_caller_setup_arg_splat(rb_control_frame_t *cfp,
struct rb_calling_info *calling,
VALUE ary,
int max_args)
2777 vm_check_canary(GET_EC(), cfp->sp);
2783 int argc = calling->argc;
2785 if (UNLIKELY(max_args <= ALLOW_HEAP_ARGV && len + argc > VM_ARGC_STACK_MAX)) {
2789 VALUE *argv = cfp->sp - argc;
2793 cfp->sp -= argc - 1;
2794 cfp->sp[-1] = argv_ary;
2796 calling->heap_argv = argv_ary;
2802 if (max_args >= 0 &&
len + argc > max_args) {
2810 calling->argc +=
len - (max_args - argc + 1);
2811 len = max_args - argc + 1;
2820 calling->heap_argv = 0;
2822 CHECK_VM_STACK_OVERFLOW(cfp,
len);
2824 for (i = 0; i <
len; i++) {
2825 *cfp->sp++ =
ptr[i];
2837 const VALUE *
const passed_keywords = vm_ci_kwarg(ci)->keywords;
2838 const int kw_len = vm_ci_kwarg(ci)->keyword_len;
2839 const VALUE h = rb_hash_new_with_size(kw_len);
2840 VALUE *sp = cfp->sp;
2843 for (i=0; i<kw_len; i++) {
2844 rb_hash_aset(h, passed_keywords[i], (sp - kw_len)[i]);
2848 cfp->sp -= kw_len - 1;
2849 calling->argc -= kw_len - 1;
2850 calling->kw_splat = 1;
2854vm_caller_setup_keyword_hash(
const struct rb_callinfo *ci,
VALUE keyword_hash)
2856 if (UNLIKELY(!RB_TYPE_P(keyword_hash,
T_HASH))) {
2857 if (keyword_hash !=
Qnil) {
2859 keyword_hash = rb_hash_dup(rb_to_hash_type(keyword_hash));
2862 else if (!IS_ARGS_KW_SPLAT_MUT(ci) && !
RHASH_EMPTY_P(keyword_hash)) {
2868 keyword_hash = rb_hash_dup(keyword_hash);
2870 return keyword_hash;
2876 const struct rb_callinfo *restrict ci,
int max_args)
2878 if (UNLIKELY(IS_ARGS_SPLAT(ci))) {
2879 if (IS_ARGS_KW_SPLAT(ci)) {
2881 VM_ASSERT(calling->kw_splat == 1);
2885 VALUE ary = cfp->sp[0];
2886 VALUE kwh = vm_caller_setup_keyword_hash(ci, cfp->sp[1]);
2889 if (vm_caller_setup_arg_splat(cfp, calling, ary, max_args))
return;
2893 if (UNLIKELY(calling->heap_argv)) {
2895 ((
struct RHash *)kwh)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
2896 if (max_args != ALLOW_HEAP_ARGV_KEEP_KWSPLAT) {
2897 calling->kw_splat = 0;
2905 VM_ASSERT(calling->kw_splat == 1);
2909 calling->kw_splat = 0;
2914 VM_ASSERT(calling->kw_splat == 0);
2918 VALUE ary = cfp->sp[0];
2920 if (vm_caller_setup_arg_splat(cfp, calling, ary, max_args)) {
2925 VALUE last_hash, argv_ary;
2926 if (UNLIKELY(argv_ary = calling->heap_argv)) {
2927 if (!IS_ARGS_KEYWORD(ci) &&
2929 RB_TYPE_P((last_hash = rb_ary_last(0, NULL, argv_ary)),
T_HASH) &&
2930 (((
struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS)) {
2935 calling->kw_splat = 1;
2941 if (!IS_ARGS_KEYWORD(ci) &&
2942 calling->argc > 0 &&
2943 RB_TYPE_P((last_hash = cfp->sp[-1]),
T_HASH) &&
2944 (((
struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS)) {
2951 cfp->sp[-1] = rb_hash_dup(last_hash);
2952 calling->kw_splat = 1;
2958 else if (UNLIKELY(IS_ARGS_KW_SPLAT(ci))) {
2960 VM_ASSERT(calling->kw_splat == 1);
2961 VALUE kwh = vm_caller_setup_keyword_hash(ci, cfp->sp[-1]);
2966 calling->kw_splat = 0;
2972 else if (UNLIKELY(IS_ARGS_KEYWORD(ci))) {
2974 VM_ASSERT(calling->kw_splat == 0);
2980 vm_caller_setup_arg_kw(cfp, calling, ci);
2984#define USE_OPT_HIST 0
2987#define OPT_HIST_MAX 64
2988static int opt_hist[OPT_HIST_MAX+1];
2992opt_hist_show_results_at_exit(
void)
2994 for (
int i=0; i<OPT_HIST_MAX; i++) {
2995 ruby_debug_printf(
"opt_hist\t%d\t%d\n", i, opt_hist[i]);
3001vm_call_iseq_setup_normal_opt_start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3005 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3006 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3007 const int opt = calling->argc - lead_num;
3008 const int opt_num = ISEQ_BODY(iseq)->param.opt_num;
3009 const int opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
3010 const int param = ISEQ_BODY(iseq)->param.size;
3011 const int local = ISEQ_BODY(iseq)->local_table_size;
3012 const int delta = opt_num - opt;
3014 RB_DEBUG_COUNTER_INC(ccf_iseq_opt);
3017 if (opt_pc < OPT_HIST_MAX) {
3021 opt_hist[OPT_HIST_MAX]++;
3025 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), opt_pc, param - delta, local);
3029vm_call_iseq_setup_tailcall_opt_start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3033 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3034 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3035 const int opt = calling->argc - lead_num;
3036 const int opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
3038 RB_DEBUG_COUNTER_INC(ccf_iseq_opt);
3041 if (opt_pc < OPT_HIST_MAX) {
3045 opt_hist[OPT_HIST_MAX]++;
3049 return vm_call_iseq_setup_tailcall(ec, cfp, calling, opt_pc);
3053args_setup_kw_parameters(rb_execution_context_t *
const ec,
const rb_iseq_t *
const iseq,
const rb_callable_method_entry_t *cme,
3054 VALUE *
const passed_values,
const int passed_keyword_len,
const VALUE *
const passed_keywords,
3055 VALUE *
const locals);
3058vm_call_iseq_forwardable(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3062 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3063 int param_size = ISEQ_BODY(iseq)->param.size;
3064 int local_size = ISEQ_BODY(iseq)->local_table_size;
3067 VM_ASSERT(ISEQ_BODY(iseq)->param.flags.forwardable);
3069 local_size = local_size + vm_ci_argc(calling->cd->ci);
3070 param_size = param_size + vm_ci_argc(calling->cd->ci);
3072 cfp->sp[0] = (
VALUE)calling->cd->ci;
3074 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param_size, local_size);
3078vm_call_iseq_setup_kwparm_kwarg(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3084 VM_ASSERT(vm_ci_flag(ci) & VM_CALL_KWARG);
3085 RB_DEBUG_COUNTER_INC(ccf_iseq_kw1);
3087 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3088 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3090 const int ci_kw_len = kw_arg->keyword_len;
3091 const VALUE *
const ci_keywords = kw_arg->keywords;
3092 VALUE *argv = cfp->sp - calling->argc;
3093 VALUE *
const klocals = argv + kw_param->bits_start - kw_param->num;
3094 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3096 MEMCPY(ci_kws, argv + lead_num,
VALUE, ci_kw_len);
3097 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), ci_kws, ci_kw_len, ci_keywords, klocals);
3099 int param = ISEQ_BODY(iseq)->param.size;
3100 int local = ISEQ_BODY(iseq)->local_table_size;
3101 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
3105vm_call_iseq_setup_kwparm_nokwarg(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3108 const struct rb_callinfo *MAYBE_UNUSED(ci) = calling->cd->ci;
3111 VM_ASSERT((vm_ci_flag(ci) & VM_CALL_KWARG) == 0);
3112 RB_DEBUG_COUNTER_INC(ccf_iseq_kw2);
3114 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3115 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3116 VALUE *
const argv = cfp->sp - calling->argc;
3117 VALUE *
const klocals = argv + kw_param->bits_start - kw_param->num;
3120 for (i=0; i<kw_param->num; i++) {
3121 klocals[i] = kw_param->default_values[i];
3128 int param = ISEQ_BODY(iseq)->param.size;
3129 int local = ISEQ_BODY(iseq)->local_table_size;
3130 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
3133static VALUE builtin_invoker0(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr);
3136vm_call_single_noarg_leaf_builtin(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3141 vm_call_handler call = (vm_call_handler)(uintptr_t)rbimpl_atomic_ptr_load((
void **)&cc->call_, RBIMPL_ATOMIC_ACQUIRE);
3142 if (UNLIKELY(call != vm_call_single_noarg_leaf_builtin)) {
3143 return call(ec, cfp, calling);
3146 cfp->sp -= (calling->argc + 1);
3147 rb_insn_func_t func_ptr = (rb_insn_func_t)(uintptr_t)bf->func_ptr;
3148 return builtin_invoker0(ec, calling->recv, NULL, func_ptr);
3154warn_unused_block(
const rb_callable_method_entry_t *cme,
const rb_iseq_t *iseq,
void *pc)
3156 rb_vm_t *vm = GET_VM();
3157 set_table *dup_check_table = vm->unused_block_warning_table;
3167 .v = (
VALUE)cme->def,
3171 if (!strict_unused_block) {
3172 key = (st_data_t)cme->def->original_id;
3174 if (set_table_lookup(dup_check_table, key)) {
3184 key |= (st_data_t)(k1.b[i] ^ k2.b[
SIZEOF_VALUE-1-i]) << (8 * i);
3189 fprintf(stderr,
"pc:%p def:%p\n", pc, (
void *)cme->def);
3190 fprintf(stderr,
"key:%p\n", (
void *)key);
3194 if (set_insert(dup_check_table, key)) {
3198 VALUE m_loc = rb_method_entry_location((
const rb_method_entry_t *)cme);
3199 VALUE name = rb_gen_method_name(cme->defined_class, ISEQ_BODY(iseq)->location.base_label);
3201 if (!
NIL_P(m_loc)) {
3202 rb_warn(
"the block passed to '%"PRIsVALUE
"' defined at %"PRIsVALUE
":%"PRIsVALUE
" may be ignored",
3206 rb_warn(
"the block may be ignored because '%"PRIsVALUE
"' does not use a block", name);
3212vm_callee_setup_arg(rb_execution_context_t *ec,
struct rb_calling_info *calling,
3213 const rb_iseq_t *iseq,
VALUE *argv,
int param_size,
int local_size)
3218 VM_ASSERT((vm_ci_argc(ci), 1));
3219 VM_ASSERT(vm_cc_cme(cc) != NULL);
3221 if (UNLIKELY(!ISEQ_BODY(iseq)->param.flags.use_block &&
3222 calling->block_handler != VM_BLOCK_HANDLER_NONE &&
3223 !(vm_ci_flag(calling->cd->ci) & (VM_CALL_OPT_SEND | VM_CALL_SUPER)))) {
3224 warn_unused_block(vm_cc_cme(cc), iseq, (
void *)ec->cfp->pc);
3227 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_KW_SPLAT))) {
3228 if (LIKELY(rb_simple_iseq_p(iseq))) {
3229 rb_control_frame_t *cfp = ec->cfp;
3230 int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3231 CALLER_SETUP_ARG(cfp, calling, ci, lead_num);
3233 if (calling->argc != lead_num) {
3234 argument_arity_error(ec, iseq, vm_cc_cme(cc), calling->argc, lead_num, lead_num);
3238 VM_ASSERT(cc == calling->cc);
3240 if (vm_call_iseq_optimizable_p(ci, cc)) {
3241 if ((ISEQ_BODY(iseq)->builtin_attrs & BUILTIN_ATTR_SINGLE_NOARG_LEAF) && ruby_vm_c_events_enabled == 0) {
3242 VM_ASSERT(ISEQ_BODY(iseq)->builtin_attrs & BUILTIN_ATTR_LEAF);
3243 vm_cc_bf_set(cc, (
void *)ISEQ_BODY(iseq)->iseq_encoded[1]);
3244 rbimpl_atomic_ptr_store((
volatile void **)&cc->call_,
3245 (
void *)(uintptr_t)vm_call_single_noarg_leaf_builtin,
3246 RBIMPL_ATOMIC_RELEASE);
3249 CC_SET_FASTPATH(cc, vm_call_iseq_setup_func(ci, param_size, local_size),
true);
3254 else if (rb_iseq_only_optparam_p(iseq)) {
3255 rb_control_frame_t *cfp = ec->cfp;
3257 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3258 const int opt_num = ISEQ_BODY(iseq)->param.opt_num;
3260 CALLER_SETUP_ARG(cfp, calling, ci, lead_num + opt_num);
3261 const int argc = calling->argc;
3262 const int opt = argc - lead_num;
3264 if (opt < 0 || opt > opt_num) {
3265 argument_arity_error(ec, iseq, vm_cc_cme(cc), argc, lead_num, lead_num + opt_num);
3268 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {
3269 CC_SET_FASTPATH(cc, vm_call_iseq_setup_normal_opt_start,
3270 !IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&
3271 vm_call_cacheable(ci, cc));
3274 CC_SET_FASTPATH(cc, vm_call_iseq_setup_tailcall_opt_start,
3275 !IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&
3276 vm_call_cacheable(ci, cc));
3280 VM_ASSERT((
int)ISEQ_BODY(iseq)->param.size == lead_num + opt_num);
3281 for (
int i=argc; i<lead_num + opt_num; i++) {
3284 return (
int)ISEQ_BODY(iseq)->param.opt_table[opt];
3286 else if (rb_iseq_only_kwparam_p(iseq) && !IS_ARGS_SPLAT(ci)) {
3287 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3288 const int argc = calling->argc;
3289 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3291 if (vm_ci_flag(ci) & VM_CALL_KWARG) {
3294 if (argc - kw_arg->keyword_len == lead_num) {
3295 const int ci_kw_len = kw_arg->keyword_len;
3296 const VALUE *
const ci_keywords = kw_arg->keywords;
3298 MEMCPY(ci_kws, argv + lead_num,
VALUE, ci_kw_len);
3300 VALUE *
const klocals = argv + kw_param->bits_start - kw_param->num;
3301 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), ci_kws, ci_kw_len, ci_keywords, klocals);
3303 CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_kwarg,
3304 vm_call_cacheable(ci, cc));
3309 else if (argc == lead_num) {
3311 VALUE *
const klocals = argv + kw_param->bits_start - kw_param->num;
3312 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), NULL, 0, NULL, klocals);
3314 if (klocals[kw_param->num] ==
INT2FIX(0)) {
3316 CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_nokwarg,
3317 vm_call_cacheable(ci, cc));
3343 if (ISEQ_BODY(iseq)->param.flags.forwardable) {
3344 bool can_fastpath =
true;
3346 if ((vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
3348 if (vm_ci_argc(ci) != vm_ci_argc(forward_cd->caller_ci)) {
3349 ci = vm_ci_new_runtime(
3356 ci = forward_cd->caller_ci;
3358 can_fastpath =
false;
3362 if (!vm_ci_markable(ci)) {
3363 ci = vm_ci_new_runtime(
3368 can_fastpath =
false;
3370 argv[param_size - 1] = (
VALUE)ci;
3371 CC_SET_FASTPATH(cc, vm_call_iseq_forwardable, can_fastpath);
3375 return setup_parameters_complex(ec, iseq, calling, ci, argv, arg_setup_method);
3402 const VALUE * lep = VM_CF_LEP(cfp);
3404 const rb_iseq_t *iseq;
3408 if (VM_ENV_FLAGS(lep, VM_ENV_FLAG_ESCAPED)) {
3413 iseq = rb_vm_search_cf_from_ep(ec, cfp, lep)->iseq;
3417 int local_size = ISEQ_BODY(iseq)->local_table_size + argc;
3419 const VALUE * from = lep - (local_size + VM_ENV_DATA_SIZE - 1);
3420 VALUE * to = cfp->sp - 1;
3424 CHECK_VM_STACK_OVERFLOW0(cfp, to,
RARRAY_LEN(splat));
3429 CHECK_VM_STACK_OVERFLOW0(cfp, to, argc);
3431 cfp->sp = to + argc;
3448vm_call_iseq_setup(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
3450 RB_DEBUG_COUNTER_INC(ccf_iseq_setup);
3453 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3454 int param_size = ISEQ_BODY(iseq)->param.size;
3455 int local_size = ISEQ_BODY(iseq)->local_table_size;
3457 RUBY_ASSERT(!ISEQ_BODY(iseq)->param.flags.forwardable);
3459 const int opt_pc = vm_callee_setup_arg(ec, calling, iseq, cfp->sp - calling->argc, param_size, local_size);
3460 return vm_call_iseq_setup_2(ec, cfp, calling, opt_pc, param_size, local_size);
3464vm_call_iseq_fwd_setup(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
3466 RB_DEBUG_COUNTER_INC(ccf_iseq_setup);
3469 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3470 int param_size = ISEQ_BODY(iseq)->param.size;
3471 int local_size = ISEQ_BODY(iseq)->local_table_size;
3473 RUBY_ASSERT(ISEQ_BODY(iseq)->param.flags.forwardable);
3476 local_size = local_size + vm_ci_argc(calling->cd->ci);
3477 param_size = param_size + vm_ci_argc(calling->cd->ci);
3479 const int opt_pc = vm_callee_setup_arg(ec, calling, iseq, cfp->sp - calling->argc, param_size, local_size);
3480 return vm_call_iseq_setup_2(ec, cfp, calling, opt_pc, param_size, local_size);
3484vm_call_iseq_setup_2(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
3485 int opt_pc,
int param_size,
int local_size)
3490 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {
3491 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), opt_pc, param_size, local_size);
3494 return vm_call_iseq_setup_tailcall(ec, cfp, calling, opt_pc);
3499vm_call_iseq_setup_normal(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
const rb_callable_method_entry_t *me,
3500 int opt_pc,
int param_size,
int local_size)
3502 const rb_iseq_t *iseq = def_iseq_ptr(me->def);
3503 VALUE *argv = cfp->sp - calling->argc;
3504 VALUE *sp = argv + param_size;
3505 cfp->sp = argv - 1 ;
3507 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL, calling->recv,
3508 calling->block_handler, (
VALUE)me,
3509 ISEQ_BODY(iseq)->iseq_encoded + opt_pc, sp,
3510 local_size - param_size,
3511 ISEQ_BODY(iseq)->stack_max);
3516vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
int opt_pc)
3520 VALUE *argv = cfp->sp - calling->argc;
3521 const rb_callable_method_entry_t *me = vm_cc_cme(cc);
3522 const rb_iseq_t *iseq = def_iseq_ptr(me->def);
3523 VALUE *src_argv = argv;
3524 VALUE *sp_orig, *sp;
3525 VALUE finish_flag = VM_FRAME_FINISHED_P(cfp) ? VM_FRAME_FLAG_FINISH : 0;
3527 if (VM_BH_FROM_CFP_P(calling->block_handler, cfp)) {
3528 struct rb_captured_block *dst_captured = VM_CFP_TO_CAPTURED_BLOCK(RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
3529 const struct rb_captured_block *src_captured = VM_BH_TO_CAPT_BLOCK(calling->block_handler);
3530 dst_captured->code.val = src_captured->code.val;
3531 if (VM_BH_ISEQ_BLOCK_P(calling->block_handler)) {
3532 calling->block_handler = VM_BH_FROM_ISEQ_BLOCK(dst_captured);
3535 calling->block_handler = VM_BH_FROM_IFUNC_BLOCK(dst_captured);
3539 vm_pop_frame(ec, cfp, cfp->ep);
3542 sp_orig = sp = cfp->sp;
3545 sp[0] = calling->recv;
3549 for (i=0; i < ISEQ_BODY(iseq)->param.size; i++) {
3550 *sp++ = src_argv[i];
3553 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL | finish_flag,
3554 calling->recv, calling->block_handler, (
VALUE)me,
3555 ISEQ_BODY(iseq)->iseq_encoded + opt_pc, sp,
3556 ISEQ_BODY(iseq)->local_table_size - ISEQ_BODY(iseq)->param.size,
3557 ISEQ_BODY(iseq)->stack_max);
3565ractor_unsafe_check(
void)
3567 if (!rb_ractor_main_p()) {
3568 rb_raise(rb_eRactorUnsafeError,
"ractor unsafe method called from not main ractor");
3575 ractor_unsafe_check();
3583 ractor_unsafe_check();
3585 return (*f)(argc, argv, recv);
3591 ractor_unsafe_check();
3599 ractor_unsafe_check();
3601 return (*f)(recv, argv[0]);
3607 ractor_unsafe_check();
3609 return (*f)(recv, argv[0], argv[1]);
3615 ractor_unsafe_check();
3617 return (*f)(recv, argv[0], argv[1], argv[2]);
3623 ractor_unsafe_check();
3625 return (*f)(recv, argv[0], argv[1], argv[2], argv[3]);
3631 ractor_unsafe_check();
3632 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3633 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4]);
3639 ractor_unsafe_check();
3640 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3641 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
3647 ractor_unsafe_check();
3648 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3649 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
3655 ractor_unsafe_check();
3656 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3657 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
3663 ractor_unsafe_check();
3664 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3665 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
3671 ractor_unsafe_check();
3672 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3673 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]);
3679 ractor_unsafe_check();
3680 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3681 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]);
3687 ractor_unsafe_check();
3688 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3689 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]);
3695 ractor_unsafe_check();
3696 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3697 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12]);
3703 ractor_unsafe_check();
3704 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3705 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13]);
3711 ractor_unsafe_check();
3712 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3713 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14]);
3727 return (*f)(argc, argv, recv);
3741 return (*f)(recv, argv[0]);
3748 return (*f)(recv, argv[0], argv[1]);
3755 return (*f)(recv, argv[0], argv[1], argv[2]);
3762 return (*f)(recv, argv[0], argv[1], argv[2], argv[3]);
3768 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3769 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4]);
3775 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3776 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
3782 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3783 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
3789 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3790 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
3796 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3797 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
3803 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3804 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]);
3810 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3811 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]);
3817 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3818 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]);
3824 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3825 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12]);
3831 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3832 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13]);
3838 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3839 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14]);
3843vm_cfp_consistent_p(rb_execution_context_t *ec,
const rb_control_frame_t *reg_cfp)
3845 const int ov_flags = RAISED_STACKOVERFLOW;
3846 if (LIKELY(reg_cfp == ec->cfp + 1))
return TRUE;
3847 if (rb_ec_raised_p(ec, ov_flags)) {
3848 rb_ec_raised_reset(ec, ov_flags);
3854#define CHECK_CFP_CONSISTENCY(func) \
3855 (LIKELY(vm_cfp_consistent_p(ec, reg_cfp)) ? (void)0 : \
3856 rb_bug(func ": cfp consistency error (%p, %p)", (void *)reg_cfp, (void *)(ec->cfp+1)))
3859const rb_method_cfunc_t *
3860vm_method_cfunc_entry(
const rb_callable_method_entry_t *me)
3862#if VM_DEBUG_VERIFY_METHOD_CACHE
3863 switch (me->def->type) {
3864 case VM_METHOD_TYPE_CFUNC:
3865 case VM_METHOD_TYPE_NOTIMPLEMENTED:
3867# define METHOD_BUG(t) case VM_METHOD_TYPE_##t: rb_bug("wrong method type: " #t)
3869 METHOD_BUG(ATTRSET);
3871 METHOD_BUG(BMETHOD);
3874 METHOD_BUG(OPTIMIZED);
3875 METHOD_BUG(MISSING);
3876 METHOD_BUG(REFINED);
3880 rb_bug(
"wrong method type: %d", me->def->type);
3883 return UNALIGNED_MEMBER_PTR(me->def, body.cfunc);
3887vm_call_cfunc_with_frame_(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling,
3890 RB_DEBUG_COUNTER_INC(ccf_cfunc_with_frame);
3894 const rb_callable_method_entry_t *me = vm_cc_cme(cc);
3895 const rb_method_cfunc_t *cfunc = vm_method_cfunc_entry(me);
3897 VALUE recv = calling->recv;
3898 VALUE block_handler = calling->block_handler;
3899 VALUE frame_type = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
3901 if (UNLIKELY(calling->kw_splat)) {
3902 frame_type |= VM_FRAME_FLAG_CFRAME_KW;
3905 VM_ASSERT(reg_cfp == ec->cfp);
3907 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, me->owner, me->def->original_id);
3910 vm_push_frame(ec, NULL, frame_type, recv,
3911 block_handler, (
VALUE)me,
3912 0, ec->cfp->sp, 0, 0);
3914 int len = cfunc->argc;
3915 if (
len >= 0) rb_check_arity(argc,
len,
len);
3917 reg_cfp->sp = stack_bottom;
3918 val = (*cfunc->invoker)(recv, argc, argv, cfunc->func);
3920 CHECK_CFP_CONSISTENCY(
"vm_call_cfunc");
3922 rb_vm_pop_frame(ec);
3924 VM_ASSERT(ec->cfp->sp == stack_bottom);
3926 EXEC_EVENT_HOOK(ec,
RUBY_EVENT_C_RETURN, recv, me->def->original_id, vm_ci_mid(ci), me->owner, val);
3927 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
3935rb_vm_push_cfunc_frame(
const rb_callable_method_entry_t *cme,
int recv_idx)
3937 VM_ASSERT(cme->def->type == VM_METHOD_TYPE_CFUNC);
3938 rb_execution_context_t *ec = GET_EC();
3939 VALUE *sp = ec->cfp->sp;
3940 VALUE recv = *(sp - recv_idx - 1);
3941 VALUE frame_type = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
3942 VALUE block_handler = VM_BLOCK_HANDLER_NONE;
3943#if VM_CHECK_MODE > 0
3945 *(GET_EC()->cfp->sp) =
Qfalse;
3947 vm_push_frame(ec, NULL, frame_type, recv, block_handler, (
VALUE)cme, 0, ec->cfp->sp, 0, 0);
3952rb_splat_or_kwargs_p(
const struct rb_callinfo *restrict ci)
3954 return IS_ARGS_SPLAT(ci) || IS_ARGS_KW_OR_KW_SPLAT(ci);
3958vm_call_cfunc_with_frame(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
3960 int argc = calling->argc;
3961 VALUE *stack_bottom = reg_cfp->sp - argc - 1;
3962 VALUE *argv = &stack_bottom[1];
3964 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, argv, stack_bottom);
3968vm_call_cfunc_other(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
3971 RB_DEBUG_COUNTER_INC(ccf_cfunc_other);
3973 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV_KEEP_KWSPLAT);
3975 if (UNLIKELY(argv_ary = calling->heap_argv)) {
3976 VM_ASSERT(!IS_ARGS_KEYWORD(ci));
3977 int argc = RARRAY_LENINT(argv_ary);
3979 VALUE *stack_bottom = reg_cfp->sp - 2;
3981 VM_ASSERT(calling->argc == 1);
3982 VM_ASSERT(RB_TYPE_P(argv_ary,
T_ARRAY));
3983 VM_ASSERT(RBASIC_CLASS(argv_ary) == 0);
3985 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, argv, stack_bottom);
3988 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_with_frame, !rb_splat_or_kwargs_p(ci) && !calling->kw_splat && !(vm_ci_flag(ci) & VM_CALL_FORWARDING));
3990 return vm_call_cfunc_with_frame(ec, reg_cfp, calling);
3995vm_call_cfunc_array_argv(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling,
int stack_offset,
int argc_offset)
3997 VALUE argv_ary = reg_cfp->sp[-1 - stack_offset];
3998 int argc = RARRAY_LENINT(argv_ary) - argc_offset;
4000 if (UNLIKELY(argc > VM_ARGC_STACK_MAX)) {
4001 return vm_call_cfunc_other(ec, reg_cfp, calling);
4005 calling->kw_splat = 0;
4007 VALUE *stack_bottom = reg_cfp->sp - 2 - stack_offset;
4008 VALUE *sp = stack_bottom;
4009 CHECK_VM_STACK_OVERFLOW(reg_cfp, argc);
4010 for(i = 0; i < argc; i++) {
4015 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, stack_bottom+1, stack_bottom);
4019vm_call_cfunc_only_splat(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4021 RB_DEBUG_COUNTER_INC(ccf_cfunc_only_splat);
4022 VALUE argv_ary = reg_cfp->sp[-1];
4023 int argc = RARRAY_LENINT(argv_ary);
4026 int argc_offset = 0;
4028 if (UNLIKELY(argc > 0 &&
4029 RB_TYPE_P((last_hash = argv[argc-1]),
T_HASH) &&
4030 (((
struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS))) {
4032 return vm_call_cfunc_other(ec, reg_cfp, calling);
4036 return vm_call_cfunc_array_argv(ec, reg_cfp, calling, 0, argc_offset);
4040vm_call_cfunc_only_splat_kw(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4042 RB_DEBUG_COUNTER_INC(ccf_cfunc_only_splat_kw);
4043 VALUE keyword_hash = reg_cfp->sp[-1];
4046 return vm_call_cfunc_array_argv(ec, reg_cfp, calling, 1, 0);
4049 return vm_call_cfunc_other(ec, reg_cfp, calling);
4053vm_call_cfunc(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4056 RB_DEBUG_COUNTER_INC(ccf_cfunc);
4058 if (IS_ARGS_SPLAT(ci) && !(vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
4059 if (!IS_ARGS_KW_SPLAT(ci) && vm_ci_argc(ci) == 1) {
4061 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_only_splat, TRUE);
4062 return vm_call_cfunc_only_splat(ec, reg_cfp, calling);
4064 if (IS_ARGS_KW_SPLAT(ci) && vm_ci_argc(ci) == 2) {
4066 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_only_splat_kw, TRUE);
4067 return vm_call_cfunc_only_splat_kw(ec, reg_cfp, calling);
4071 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_other, TRUE);
4072 return vm_call_cfunc_other(ec, reg_cfp, calling);
4076vm_call_ivar(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4079 RB_DEBUG_COUNTER_INC(ccf_ivar);
4081 VALUE ivar = vm_getivar(calling->recv, vm_cc_cme(cc)->def->body.attr.id, NULL, NULL, cc, TRUE,
Qnil);
4086vm_call_attrset_direct(rb_execution_context_t *ec, rb_control_frame_t *cfp,
const struct rb_callcache *cc,
VALUE obj)
4088 RB_DEBUG_COUNTER_INC(ccf_attrset);
4089 VALUE val = *(cfp->sp - 1);
4092 shape_id_t dest_shape_id;
4093 vm_cc_atomic_shape_and_index(cc, &dest_shape_id, &index);
4094 ID id = vm_cc_cme(cc)->def->body.attr.id;
4095 rb_check_frozen(obj);
4096 VALUE res = vm_setivar(obj,
id, val, dest_shape_id, index);
4104 res = vm_setivar_class(obj,
id, val, dest_shape_id, index);
4105 if (!UNDEF_P(res)) {
4112 res = vm_setivar_default(obj,
id, val, dest_shape_id, index);
4113 if (!UNDEF_P(res)) {
4118 res = vm_setivar_slowpath_attr(obj,
id, val, cc);
4124vm_call_attrset(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4126 return vm_call_attrset_direct(ec, cfp, calling->cc, calling->recv);
4130vm_call_bmethod_body(rb_execution_context_t *ec,
struct rb_calling_info *calling,
const VALUE *argv)
4135 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4136 VALUE procv = cme->def->body.bmethod.proc;
4139 cme->def->body.bmethod.defined_ractor_id != rb_ec_ractor_id(ec)) {
4140 rb_raise(
rb_eRuntimeError,
"defined with an un-shareable Proc in a different Ractor");
4144 GetProcPtr(procv, proc);
4145 val = vm_invoke_bmethod(ec, proc, calling->recv, CALLING_ARGC(calling), argv, calling->kw_splat, calling->block_handler, vm_cc_cme(cc));
4150static int vm_callee_setup_block_arg(rb_execution_context_t *ec,
struct rb_calling_info *calling,
const struct rb_callinfo *ci,
const rb_iseq_t *iseq,
VALUE *argv,
const enum arg_setup_type arg_setup_type);
4153vm_call_iseq_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4155 RB_DEBUG_COUNTER_INC(ccf_iseq_bmethod);
4158 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4159 VALUE procv = cme->def->body.bmethod.proc;
4162 cme->def->body.bmethod.defined_ractor_id != rb_ec_ractor_id(ec)) {
4163 rb_raise(
rb_eRuntimeError,
"defined with an un-shareable Proc in a different Ractor");
4167 GetProcPtr(procv, proc);
4168 const struct rb_block *block = &proc->block;
4170 while (vm_block_type(block) == block_type_proc) {
4171 block = vm_proc_block(block->as.proc);
4173 VM_ASSERT(vm_block_type(block) == block_type_iseq);
4176 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
4177 VALUE *
const argv = cfp->sp - calling->argc;
4178 const int arg_size = ISEQ_BODY(iseq)->param.size;
4181 if (vm_ci_flag(calling->cd->ci) & VM_CALL_ARGS_SIMPLE) {
4182 opt_pc = vm_callee_setup_block_arg(ec, calling, calling->cd->ci, iseq, argv, arg_setup_method);
4185 opt_pc = setup_parameters_complex(ec, iseq, calling, calling->cd->ci, argv, arg_setup_method);
4190 vm_push_frame(ec, iseq,
4191 VM_FRAME_MAGIC_BLOCK | VM_FRAME_FLAG_BMETHOD | VM_FRAME_FLAG_LAMBDA,
4193 VM_GUARDED_PREV_EP(captured->ep),
4195 ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
4197 ISEQ_BODY(iseq)->local_table_size - arg_size,
4198 ISEQ_BODY(iseq)->stack_max);
4204vm_call_noniseq_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4206 RB_DEBUG_COUNTER_INC(ccf_noniseq_bmethod);
4210 CALLER_SETUP_ARG(cfp, calling, calling->cd->ci, ALLOW_HEAP_ARGV);
4211 if (UNLIKELY(calling->heap_argv)) {
4212 argv = RARRAY_PTR(calling->heap_argv);
4216 argc = calling->argc;
4219 cfp->sp += - argc - 1;
4222 return vm_call_bmethod_body(ec, calling, argv);
4226vm_call_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4228 RB_DEBUG_COUNTER_INC(ccf_bmethod);
4231 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4232 VALUE procv = cme->def->body.bmethod.proc;
4234 GetProcPtr(procv, proc);
4235 const struct rb_block *block = &proc->block;
4237 while (vm_block_type(block) == block_type_proc) {
4238 block = vm_proc_block(block->as.proc);
4240 if (vm_block_type(block) == block_type_iseq) {
4241 CC_SET_FASTPATH(cc, vm_call_iseq_bmethod, TRUE);
4242 return vm_call_iseq_bmethod(ec, cfp, calling);
4245 CC_SET_FASTPATH(cc, vm_call_noniseq_bmethod, TRUE);
4246 return vm_call_noniseq_bmethod(ec, cfp, calling);
4250rb_find_defined_class_by_owner(
VALUE current_class,
VALUE target_owner)
4252 VALUE klass = current_class;
4255 if (RB_TYPE_P(klass,
T_ICLASS) && RICLASS_IS_ORIGIN_P(klass) &&
4256 RB_TYPE_P(RBASIC_CLASS(klass),
T_CLASS)) {
4257 klass = RBASIC_CLASS(klass);
4260 while (
RTEST(klass)) {
4261 VALUE owner = RB_TYPE_P(klass,
T_ICLASS) ? RBASIC_CLASS(klass) : klass;
4262 if (owner == target_owner) {
4268 return current_class;
4271static const rb_callable_method_entry_t *
4272aliased_callable_method_entry(
const rb_callable_method_entry_t *me)
4274 const rb_method_entry_t *orig_me = me->def->body.alias.original_me;
4275 const rb_callable_method_entry_t *cme;
4277 if (orig_me->defined_class == 0) {
4278 VALUE defined_class = rb_find_defined_class_by_owner(me->defined_class, orig_me->owner);
4279 VM_ASSERT_TYPE(orig_me->owner,
T_MODULE);
4280 cme = rb_method_entry_complement_defined_class(orig_me, me->called_id, defined_class);
4282 if (me->def->reference_count == 1) {
4283 RB_OBJ_WRITE(me, &me->def->body.alias.original_me, cme);
4286 rb_method_definition_t *def =
4287 rb_method_definition_create(VM_METHOD_TYPE_ALIAS, me->def->original_id);
4288 rb_method_definition_set((rb_method_entry_t *)me, def, (
void *)cme);
4292 cme = (
const rb_callable_method_entry_t *)orig_me;
4295 VM_ASSERT(callable_method_entry_p(cme));
4299const rb_callable_method_entry_t *
4300rb_aliased_callable_method_entry(
const rb_callable_method_entry_t *me)
4302 return aliased_callable_method_entry(me);
4306vm_call_alias(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4308 calling->cc = &VM_CC_ON_STACK(
Qundef,
4311 aliased_callable_method_entry(vm_cc_cme(calling->cc)));
4313 return vm_call_method_each_type(ec, cfp, calling);
4316static enum method_missing_reason
4319 enum method_missing_reason stat = MISSING_NOENTRY;
4320 if (vm_ci_flag(ci) & VM_CALL_VCALL && !(vm_ci_flag(ci) & VM_CALL_FORWARDING)) stat |= MISSING_VCALL;
4321 if (vm_ci_flag(ci) & VM_CALL_FCALL) stat |= MISSING_FCALL;
4322 if (vm_ci_flag(ci) & VM_CALL_SUPER) stat |= MISSING_SUPER;
4326static VALUE vm_call_method_missing(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling);
4329vm_call_symbol(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4332 ASSUME(calling->argc >= 0);
4334 enum method_missing_reason missing_reason = MISSING_NOENTRY;
4335 int argc = calling->argc;
4336 VALUE recv = calling->recv;
4339 flags |= VM_CALL_OPT_SEND;
4341 if (UNLIKELY(! mid)) {
4342 mid = idMethodMissing;
4343 missing_reason = ci_missing_reason(ci);
4344 ec->method_missing_reason = missing_reason;
4347 if (UNLIKELY(argv_ary = calling->heap_argv)) {
4348 if (rb_method_basic_definition_p(klass, idMethodMissing)) {
4349 rb_ary_unshift(argv_ary, symbol);
4352 int priv = vm_ci_flag(ci) & (VM_CALL_FCALL | VM_CALL_VCALL);
4353 VALUE exc = rb_make_no_method_exception(
4375 CHECK_VM_STACK_OVERFLOW(reg_cfp, 1);
4378 argc = ++calling->argc;
4380 if (rb_method_basic_definition_p(klass, idMethodMissing)) {
4383 int priv = vm_ci_flag(ci) & (VM_CALL_FCALL | VM_CALL_VCALL);
4384 const VALUE *argv = STACK_ADDR_FROM_TOP(argc);
4385 VALUE exc = rb_make_no_method_exception(
4398 .ci = &VM_CI_ON_STACK(mid, flags, argc, vm_ci_kwarg(ci)),
4404 if (!(vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
4405 calling->cd = &new_fcd.cd;
4409 VM_ASSERT((vm_ci_argc(caller_ci), 1));
4410 new_fcd.caller_ci = caller_ci;
4413 calling->cc = &VM_CC_ON_STACK(klass,
4415 { .method_missing_reason = missing_reason },
4416 rb_callable_method_entry_with_refinements(klass, mid, NULL));
4418 if (flags & VM_CALL_FCALL) {
4419 return vm_call_method(ec, reg_cfp, calling);
4423 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
4425 if (vm_cc_cme(cc) != NULL) {
4426 switch (METHOD_ENTRY_VISI(vm_cc_cme(cc))) {
4427 case METHOD_VISI_PUBLIC:
4428 return vm_call_method_each_type(ec, reg_cfp, calling);
4429 case METHOD_VISI_PRIVATE:
4430 vm_cc_method_missing_reason_set(cc, MISSING_PRIVATE);
4432 case METHOD_VISI_PROTECTED:
4433 vm_cc_method_missing_reason_set(cc, MISSING_PROTECTED);
4436 VM_UNREACHABLE(vm_call_method);
4438 return vm_call_method_missing(ec, reg_cfp, calling);
4441 return vm_call_method_nome(ec, reg_cfp, calling);
4445vm_call_opt_send0(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling,
int flags)
4451 i = calling->argc - 1;
4453 if (calling->argc == 0) {
4454 rb_raise(rb_eArgError,
"no method name given");
4478 return vm_call_symbol(ec, reg_cfp, calling, ci, sym, flags);
4482vm_call_opt_send_complex(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4484 RB_DEBUG_COUNTER_INC(ccf_opt_send_complex);
4486 int flags = VM_CALL_FCALL;
4490 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV);
4491 if (UNLIKELY(argv_ary = calling->heap_argv)) {
4493 flags |= VM_CALL_ARGS_SPLAT;
4494 if (calling->kw_splat) {
4495 VALUE last_hash = rb_ary_last(0, NULL, argv_ary);
4496 ((
struct RHash *)last_hash)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
4497 calling->kw_splat = 0;
4499 return vm_call_symbol(ec, reg_cfp, calling, ci, sym, flags);
4502 if (calling->kw_splat) flags |= VM_CALL_KW_SPLAT;
4503 return vm_call_opt_send0(ec, reg_cfp, calling, flags);
4507vm_call_opt_send_simple(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4509 RB_DEBUG_COUNTER_INC(ccf_opt_send_simple);
4510 return vm_call_opt_send0(ec, reg_cfp, calling, vm_ci_flag(calling->cd->ci) | VM_CALL_FCALL);
4514vm_call_opt_send(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4516 RB_DEBUG_COUNTER_INC(ccf_opt_send);
4519 int flags = vm_ci_flag(ci);
4521 if (UNLIKELY((flags & VM_CALL_FORWARDING) || (!(flags & VM_CALL_ARGS_SIMPLE) &&
4522 ((calling->argc == 1 && (flags & (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT))) ||
4523 (calling->argc == 2 && (flags & VM_CALL_ARGS_SPLAT) && (flags & VM_CALL_KW_SPLAT)) ||
4524 ((flags & VM_CALL_KWARG) && (vm_ci_kwarg(ci)->keyword_len == calling->argc)))))) {
4525 CC_SET_FASTPATH(calling->cc, vm_call_opt_send_complex, TRUE);
4526 return vm_call_opt_send_complex(ec, reg_cfp, calling);
4529 CC_SET_FASTPATH(calling->cc, vm_call_opt_send_simple, TRUE);
4530 return vm_call_opt_send_simple(ec, reg_cfp, calling);
4534vm_call_method_missing_body(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling,
4535 const struct rb_callinfo *orig_ci,
enum method_missing_reason reason)
4537 RB_DEBUG_COUNTER_INC(ccf_method_missing);
4539 VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);
4540 unsigned int argc, flag;
4542 flag = VM_CALL_FCALL | VM_CALL_OPT_SEND | vm_ci_flag(orig_ci);
4543 argc = ++calling->argc;
4546 CHECK_VM_STACK_OVERFLOW(reg_cfp, 1);
4547 vm_check_canary(ec, reg_cfp->sp);
4551 argv[0] =
ID2SYM(vm_ci_mid(orig_ci));
4554 ec->method_missing_reason = reason;
4558 .ci = &VM_CI_ON_STACK(idMethodMissing, flag, argc, vm_ci_kwarg(orig_ci)),
4564 if (!(flag & VM_CALL_FORWARDING)) {
4565 calling->cd = &new_fcd.cd;
4569 VM_ASSERT((vm_ci_argc(caller_ci), 1));
4570 new_fcd.caller_ci = caller_ci;
4574 calling->cc = &VM_CC_ON_STACK(
Qundef, vm_call_general, {{ 0 }},
4575 rb_callable_method_entry_without_refinements(
CLASS_OF(calling->recv), idMethodMissing, NULL));
4576 return vm_call_method(ec, reg_cfp, calling);
4580vm_call_method_missing(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4582 return vm_call_method_missing_body(ec, reg_cfp, calling, calling->cd->ci, vm_cc_cmethod_missing_reason(calling->cc));
4585static const rb_callable_method_entry_t *refined_method_callable_without_refinement(
const rb_callable_method_entry_t *me);
4587vm_call_zsuper(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
VALUE klass)
4591 const rb_callable_method_entry_t *cme = klass ? rb_callable_method_entry(klass, vm_ci_mid(calling->cd->ci)) : NULL;
4593 return vm_call_method_nome(ec, cfp, calling);
4595 if (cme->def->type == VM_METHOD_TYPE_REFINED &&
4596 cme->def->body.refined.orig_me) {
4597 cme = refined_method_callable_without_refinement(cme);
4600 calling->cc = &VM_CC_ON_STACK(
Qundef, vm_call_general, {{ 0 }}, cme);
4602 return vm_call_method_each_type(ec, cfp, calling);
4606find_refinement(
VALUE refinements,
VALUE klass)
4608 if (
NIL_P(refinements)) {
4611 return rb_hash_lookup(refinements, klass);
4614PUREFUNC(
static rb_control_frame_t * current_method_entry(
const rb_execution_context_t *ec, rb_control_frame_t *cfp));
4615static rb_control_frame_t *
4616current_method_entry(
const rb_execution_context_t *ec, rb_control_frame_t *cfp)
4618 rb_control_frame_t *top_cfp = cfp;
4620 if (cfp->iseq && ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_BLOCK) {
4621 const rb_iseq_t *local_iseq = ISEQ_BODY(cfp->iseq)->local_iseq;
4624 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
4625 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
4629 }
while (cfp->iseq != local_iseq);
4634static const rb_callable_method_entry_t *
4635refined_method_callable_without_refinement(
const rb_callable_method_entry_t *me)
4637 const rb_method_entry_t *orig_me = me->def->body.refined.orig_me;
4638 const rb_callable_method_entry_t *cme;
4640 if (orig_me->defined_class == 0) {
4645 cme = (
const rb_callable_method_entry_t *)orig_me;
4648 VM_ASSERT(callable_method_entry_p(cme));
4650 if (UNDEFINED_METHOD_ENTRY_P(cme)) {
4657static const rb_callable_method_entry_t *
4658search_refined_method(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4661 ID mid = vm_ci_mid(ci);
4663 const rb_cref_t *cref = (vm_ci_flag(ci) & VM_CALL_IGNORE_REFINEMENTS) ? NULL : vm_get_cref(cfp->ep);
4665 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4667 for (; cref; cref = CREF_NEXT(cref)) {
4668 const VALUE refinement = find_refinement(CREF_REFINEMENTS(cref), vm_cc_cme(cc)->owner);
4669 if (
NIL_P(refinement))
continue;
4671 const rb_callable_method_entry_t *
const ref_me =
4672 rb_callable_method_entry(refinement, mid);
4675 if (vm_cc_call(cc) == vm_call_super_method) {
4676 const rb_control_frame_t *top_cfp = current_method_entry(ec, cfp);
4677 const rb_callable_method_entry_t *top_me = rb_vm_frame_method_entry(top_cfp);
4678 if (top_me && rb_method_definition_eq(ref_me->def, top_me->def)) {
4683 if (cme->def->type != VM_METHOD_TYPE_REFINED ||
4684 cme->def != ref_me->def) {
4687 if (ref_me->def->type != VM_METHOD_TYPE_REFINED) {
4696 if (vm_cc_cme(cc)->def->body.refined.orig_me) {
4697 return refined_method_callable_without_refinement(vm_cc_cme(cc));
4701 const rb_callable_method_entry_t *cme = klass ? rb_callable_method_entry(klass, mid) : NULL;
4707vm_call_refined(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4709 const rb_callable_method_entry_t *ref_cme = search_refined_method(ec, cfp, calling);
4712 if (calling->cd->cc) {
4713 const struct rb_callcache *cc = calling->cc = vm_cc_new(vm_cc_cme(calling->cc)->defined_class, ref_cme, vm_call_general, cc_type_refinement);
4715 return vm_call_method(ec, cfp, calling);
4718 struct rb_callcache *ref_cc = &VM_CC_ON_STACK(
Qundef, vm_call_general, {{ 0 }}, ref_cme);
4719 calling->cc= ref_cc;
4720 return vm_call_method(ec, cfp, calling);
4724 return vm_call_method_nome(ec, cfp, calling);
4728static inline VALUE vm_invoke_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling,
const struct rb_callinfo *ci,
bool is_lambda,
VALUE block_handler);
4730NOINLINE(
static VALUE
4731 vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4735vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4738 int argc = calling->argc;
4741 if (argc > 0)
MEMMOVE(&TOPN(argc), &TOPN(argc-1),
VALUE, argc);
4744 return vm_invoke_block(ec, reg_cfp, calling, ci,
false, block_handler);
4748vm_call_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4750 RB_DEBUG_COUNTER_INC(ccf_opt_call);
4753 VALUE procval = calling->recv;
4754 return vm_invoke_block_opt_call(ec, reg_cfp, calling, ci, VM_BH_FROM_PROC(procval));
4758vm_call_opt_block_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4760 RB_DEBUG_COUNTER_INC(ccf_opt_block_call);
4762 VALUE block_handler = VM_ENV_BLOCK_HANDLER(VM_CF_LEP(reg_cfp));
4765 if (BASIC_OP_UNREDEFINED_P(BOP_CALL, PROC_REDEFINED_OP_FLAG)) {
4766 return vm_invoke_block_opt_call(ec, reg_cfp, calling, ci, block_handler);
4769 calling->recv = rb_vm_bh_to_procval(ec, block_handler);
4770 calling->cc = rb_vm_search_method_slowpath(ci,
CLASS_OF(calling->recv));
4771 return vm_call_general(ec, reg_cfp, calling);
4776vm_call_opt_struct_aref0(rb_execution_context_t *ec,
struct rb_calling_info *calling)
4778 VALUE recv = calling->recv;
4780 VM_ASSERT(RB_TYPE_P(recv,
T_STRUCT));
4781 VM_ASSERT(vm_cc_cme(calling->cc)->def->type == VM_METHOD_TYPE_OPTIMIZED);
4782 VM_ASSERT(vm_cc_cme(calling->cc)->def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_AREF);
4784 const unsigned int off = vm_cc_cme(calling->cc)->def->body.optimized.index;
4785 return internal_RSTRUCT_GET(recv,
off);
4789vm_call_opt_struct_aref(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4791 RB_DEBUG_COUNTER_INC(ccf_opt_struct_aref);
4793 VALUE ret = vm_call_opt_struct_aref0(ec, calling);
4799vm_call_opt_struct_aset0(rb_execution_context_t *ec,
struct rb_calling_info *calling,
VALUE val)
4801 VALUE recv = calling->recv;
4803 VM_ASSERT(RB_TYPE_P(recv,
T_STRUCT));
4804 VM_ASSERT(vm_cc_cme(calling->cc)->def->type == VM_METHOD_TYPE_OPTIMIZED);
4805 VM_ASSERT(vm_cc_cme(calling->cc)->def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_ASET);
4807 rb_check_frozen(recv);
4809 const unsigned int off = vm_cc_cme(calling->cc)->def->body.optimized.index;
4810 internal_RSTRUCT_SET(recv,
off, val);
4816vm_call_opt_struct_aset(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4818 RB_DEBUG_COUNTER_INC(ccf_opt_struct_aset);
4820 VALUE ret = vm_call_opt_struct_aset0(ec, calling, *(reg_cfp->sp - 1));
4825NOINLINE(
static VALUE vm_call_optimized(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
4828#define VM_CALL_METHOD_ATTR(var, func, nohook) \
4829 if (UNLIKELY(ruby_vm_c_events_enabled > 0)) { \
4830 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_CALL, calling->recv, vm_cc_cme(cc)->def->original_id, \
4831 vm_ci_mid(ci), vm_cc_cme(cc)->owner, Qundef); \
4833 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, calling->recv, vm_cc_cme(cc)->def->original_id, \
4834 vm_ci_mid(ci), vm_cc_cme(cc)->owner, (var)); \
4842vm_call_optimized(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
4845 switch (vm_cc_cme(cc)->def->body.optimized.type) {
4846 case OPTIMIZED_METHOD_TYPE_SEND:
4847 CC_SET_FASTPATH(cc, vm_call_opt_send, TRUE);
4848 return vm_call_opt_send(ec, cfp, calling);
4849 case OPTIMIZED_METHOD_TYPE_CALL:
4850 CC_SET_FASTPATH(cc, vm_call_opt_call, TRUE);
4851 return vm_call_opt_call(ec, cfp, calling);
4852 case OPTIMIZED_METHOD_TYPE_BLOCK_CALL:
4853 CC_SET_FASTPATH(cc, vm_call_opt_block_call, TRUE);
4854 return vm_call_opt_block_call(ec, cfp, calling);
4855 case OPTIMIZED_METHOD_TYPE_STRUCT_AREF: {
4856 CALLER_SETUP_ARG(cfp, calling, ci, 0);
4857 rb_check_arity(calling->argc, 0, 0);
4860 VM_CALL_METHOD_ATTR(v,
4861 vm_call_opt_struct_aref(ec, cfp, calling),
4862 set_vm_cc_ivar(cc); \
4863 CC_SET_FASTPATH(cc, vm_call_opt_struct_aref, (vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE)))
4866 case OPTIMIZED_METHOD_TYPE_STRUCT_ASET: {
4867 CALLER_SETUP_ARG(cfp, calling, ci, 1);
4868 rb_check_arity(calling->argc, 1, 1);
4871 VM_CALL_METHOD_ATTR(v,
4872 vm_call_opt_struct_aset(ec, cfp, calling),
4873 set_vm_cc_ivar(cc); \
4874 CC_SET_FASTPATH(cc, vm_call_opt_struct_aset, (vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE)))
4878 rb_bug(
"vm_call_method: unsupported optimized method type (%d)", vm_cc_cme(cc)->def->body.optimized.type);
4883vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4887 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4890 VM_ASSERT(! METHOD_ENTRY_INVALIDATED(cme));
4892 switch (cme->def->type) {
4893 case VM_METHOD_TYPE_ISEQ:
4894 if (ISEQ_BODY(def_iseq_ptr(cme->def))->param.flags.forwardable) {
4895 CC_SET_FASTPATH(cc, vm_call_iseq_fwd_setup, TRUE);
4896 return vm_call_iseq_fwd_setup(ec, cfp, calling);
4899 CC_SET_FASTPATH(cc, vm_call_iseq_setup, TRUE);
4900 return vm_call_iseq_setup(ec, cfp, calling);
4903 case VM_METHOD_TYPE_NOTIMPLEMENTED:
4904 case VM_METHOD_TYPE_CFUNC:
4905 CC_SET_FASTPATH(cc, vm_call_cfunc, TRUE);
4906 return vm_call_cfunc(ec, cfp, calling);
4908 case VM_METHOD_TYPE_ATTRSET:
4909 CALLER_SETUP_ARG(cfp, calling, ci, 1);
4911 rb_check_arity(calling->argc, 1, 1);
4913 const unsigned int aset_mask = (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT | VM_CALL_KWARG | VM_CALL_FORWARDING);
4915 if (vm_cc_markable(cc)) {
4916 vm_cc_attr_index_initialize(cc, INVALID_SHAPE_ID);
4917 VM_CALL_METHOD_ATTR(v,
4918 vm_call_attrset_direct(ec, cfp, cc, calling->recv),
4919 CC_SET_FASTPATH(cc, vm_call_attrset, !(vm_ci_flag(ci) & aset_mask)));
4925 VM_CALLCACHE_UNMARKABLE |
4926 VM_CALLCACHE_ON_STACK,
4932 .value = vm_pack_shape_and_index(INVALID_SHAPE_ID, ATTR_INDEX_NOT_SET),
4937 VM_CALL_METHOD_ATTR(v,
4938 vm_call_attrset_direct(ec, cfp, cc, calling->recv),
4939 CC_SET_FASTPATH(cc, vm_call_attrset, !(vm_ci_flag(ci) & aset_mask)));
4943 case VM_METHOD_TYPE_IVAR:
4944 CALLER_SETUP_ARG(cfp, calling, ci, 0);
4945 rb_check_arity(calling->argc, 0, 0);
4946 vm_cc_attr_index_initialize(cc, INVALID_SHAPE_ID);
4947 const unsigned int ivar_mask = (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT | VM_CALL_FORWARDING);
4948 VM_CALL_METHOD_ATTR(v,
4949 vm_call_ivar(ec, cfp, calling),
4950 CC_SET_FASTPATH(cc, vm_call_ivar, !(vm_ci_flag(ci) & ivar_mask)));
4953 case VM_METHOD_TYPE_MISSING:
4954 vm_cc_method_missing_reason_set(cc, 0);
4955 CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);
4956 return vm_call_method_missing(ec, cfp, calling);
4958 case VM_METHOD_TYPE_BMETHOD:
4959 CC_SET_FASTPATH(cc, vm_call_bmethod, TRUE);
4960 return vm_call_bmethod(ec, cfp, calling);
4962 case VM_METHOD_TYPE_ALIAS:
4963 CC_SET_FASTPATH(cc, vm_call_alias, TRUE);
4964 return vm_call_alias(ec, cfp, calling);
4966 case VM_METHOD_TYPE_OPTIMIZED:
4967 return vm_call_optimized(ec, cfp, calling, ci, cc);
4969 case VM_METHOD_TYPE_UNDEF:
4972 case VM_METHOD_TYPE_ZSUPER:
4973 return vm_call_zsuper(ec, cfp, calling, RCLASS_ORIGIN(vm_cc_cme(cc)->defined_class));
4975 case VM_METHOD_TYPE_REFINED:
4978 return vm_call_refined(ec, cfp, calling);
4981 rb_bug(
"vm_call_method: unsupported method type (%d)", vm_cc_cme(cc)->def->type);
4984NORETURN(
static void vm_raise_method_missing(rb_execution_context_t *ec,
int argc,
const VALUE *argv,
VALUE obj,
int call_status));
4987vm_call_method_nome(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4991 const int stat = ci_missing_reason(ci);
4993 if (vm_ci_mid(ci) == idMethodMissing) {
4994 if (UNLIKELY(calling->heap_argv)) {
4995 vm_raise_method_missing(ec, RARRAY_LENINT(calling->heap_argv),
RARRAY_CONST_PTR(calling->heap_argv), calling->recv, stat);
4998 rb_control_frame_t *reg_cfp = cfp;
4999 VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);
5000 vm_raise_method_missing(ec, calling->argc, argv, calling->recv, stat);
5004 return vm_call_method_missing_body(ec, cfp, calling, ci, stat);
5014vm_defined_class_for_protected_call(
const rb_callable_method_entry_t *me)
5016 VALUE defined_class = me->defined_class;
5017 VALUE refined_class = RCLASS_REFINED_CLASS(defined_class);
5018 return NIL_P(refined_class) ? defined_class : refined_class;
5022vm_call_method(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
5027 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
5029 if (vm_cc_cme(cc) != NULL) {
5030 switch (METHOD_ENTRY_VISI(vm_cc_cme(cc))) {
5031 case METHOD_VISI_PUBLIC:
5032 return vm_call_method_each_type(ec, cfp, calling);
5034 case METHOD_VISI_PRIVATE:
5035 if (!(vm_ci_flag(ci) & VM_CALL_FCALL)) {
5036 enum method_missing_reason stat = MISSING_PRIVATE;
5037 if (vm_ci_flag(ci) & VM_CALL_VCALL) stat |= MISSING_VCALL;
5039 vm_cc_method_missing_reason_set(cc, stat);
5040 CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);
5041 return vm_call_method_missing(ec, cfp, calling);
5043 return vm_call_method_each_type(ec, cfp, calling);
5045 case METHOD_VISI_PROTECTED:
5046 if (!(vm_ci_flag(ci) & (VM_CALL_OPT_SEND | VM_CALL_FCALL))) {
5047 VALUE defined_class = vm_defined_class_for_protected_call(vm_cc_cme(cc));
5049 vm_cc_method_missing_reason_set(cc, MISSING_PROTECTED);
5050 return vm_call_method_missing(ec, cfp, calling);
5054 VM_ASSERT(vm_cc_cme(cc) != NULL);
5057 calling->cc = &cc_on_stack;
5058 return vm_call_method_each_type(ec, cfp, calling);
5061 return vm_call_method_each_type(ec, cfp, calling);
5064 rb_bug(
"unreachable");
5068 return vm_call_method_nome(ec, cfp, calling);
5073vm_call_general(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
5075 RB_DEBUG_COUNTER_INC(ccf_general);
5076 return vm_call_method(ec, reg_cfp, calling);
5082 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
5083 VM_ASSERT(cc != vm_cc_empty());
5085 *(vm_call_handler *)&cc->call_ = vm_call_general;
5089vm_call_super_method(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
5091 RB_DEBUG_COUNTER_INC(ccf_super_method);
5096 if (ec == NULL) rb_bug(
"unreachable");
5099 VM_ASSERT(vm_cc_call(calling->cc) == vm_call_super_method);
5100 return vm_call_method(ec, reg_cfp, calling);
5106vm_search_normal_superclass(
VALUE klass)
5111 klass =
RBASIC(klass)->klass;
5113 klass = RCLASS_ORIGIN(klass);
5117NORETURN(
static void vm_super_outside(
void));
5120vm_super_outside(
void)
5126empty_cc_for_super(
void)
5128 return &vm_empty_cc_for_super;
5132vm_search_super_method(
const rb_control_frame_t *reg_cfp,
struct rb_call_data *cd,
VALUE recv)
5134 VALUE current_defined_class;
5135 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(reg_cfp);
5141 current_defined_class = vm_defined_class_for_protected_call(me);
5144 reg_cfp->iseq != method_entry_iseqptr(me) &&
5147 RCLASS_INCLUDER(current_defined_class) : current_defined_class;
5151 "self has wrong type to call super in this context: "
5152 "%"PRIsVALUE
" (expected %"PRIsVALUE
")",
5157 if (me->def->type == VM_METHOD_TYPE_BMETHOD && (vm_ci_flag(cd->ci) & VM_CALL_ZSUPER)) {
5159 "implicit argument passing of super from method defined"
5160 " by define_method() is not supported."
5161 " Specify all arguments explicitly.");
5164 ID mid = me->def->original_id;
5166 if (!vm_ci_markable(cd->ci)) {
5167 VM_FORCE_WRITE((
const VALUE *)&cd->ci->mid, (
VALUE)mid);
5171 cd->ci = vm_ci_new_runtime(mid,
5174 vm_ci_kwarg(cd->ci));
5181 VALUE klass = vm_search_normal_superclass(me->defined_class);
5185 cc = vm_cc_new(
Qundef, NULL, vm_call_method_missing, cc_type_super);
5189 cc = vm_search_method_fastpath((
VALUE)reg_cfp->iseq, cd, klass);
5190 const rb_callable_method_entry_t *cached_cme = vm_cc_cme(cc);
5193 if (cached_cme == NULL) {
5195 cd->cc = empty_cc_for_super();
5197 else if (cached_cme->called_id != mid) {
5198 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, mid);
5200 cc = vm_cc_new(klass, cme, vm_call_super_method, cc_type_super);
5204 cd->cc = cc = empty_cc_for_super();
5208 switch (cached_cme->def->type) {
5210 case VM_METHOD_TYPE_REFINED:
5212 case VM_METHOD_TYPE_ATTRSET:
5213 case VM_METHOD_TYPE_IVAR:
5214 vm_cc_call_set(cc, vm_call_super_method);
5222 VM_ASSERT((vm_cc_cme(cc),
true));
5230block_proc_is_lambda(
const VALUE procval)
5235 GetProcPtr(procval, proc);
5236 return proc->is_lambda;
5244vm_yield_with_cfunc(rb_execution_context_t *ec,
5246 VALUE self,
int argc,
const VALUE *argv,
int kw_splat,
VALUE block_handler,
5247 const rb_callable_method_entry_t *me)
5249 int is_lambda = FALSE;
5250 VALUE val, arg, blockarg;
5252 const struct vm_ifunc *ifunc = captured->code.ifunc;
5257 else if (argc == 0) {
5264 blockarg = rb_vm_bh_to_procval(ec, block_handler);
5266 frame_flag = VM_FRAME_MAGIC_IFUNC | VM_FRAME_FLAG_CFRAME | (me ? VM_FRAME_FLAG_BMETHOD : 0);
5268 frame_flag |= VM_FRAME_FLAG_CFRAME_KW;
5271 vm_push_frame(ec, (
const rb_iseq_t *)captured->code.ifunc,
5274 VM_GUARDED_PREV_EP(captured->ep),
5276 0, ec->cfp->sp, 0, 0);
5277 val = (*ifunc->func)(arg, (
VALUE)ifunc->data, argc, argv, blockarg);
5278 rb_vm_pop_frame(ec);
5284rb_vm_yield_with_cfunc(rb_execution_context_t *ec,
const struct rb_captured_block *captured,
int argc,
const VALUE *argv)
5286 return vm_yield_with_cfunc(ec, captured, captured->self, argc, argv, 0, VM_BLOCK_HANDLER_NONE, NULL);
5290vm_yield_with_symbol(rb_execution_context_t *ec,
VALUE symbol,
int argc,
const VALUE *argv,
int kw_splat,
VALUE block_handler)
5292 return rb_sym_proc_call(
SYM2ID(symbol), argc, argv, kw_splat, rb_vm_bh_to_procval(ec, block_handler));
5296vm_callee_setup_block_arg_arg0_splat(rb_control_frame_t *cfp,
const rb_iseq_t *iseq,
VALUE *argv,
VALUE ary)
5301 CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
5303 for (i=0; i<
len && i<ISEQ_BODY(iseq)->param.lead_num; i++) {
5311vm_callee_setup_block_arg_arg0_check(
VALUE *argv)
5313 VALUE ary, arg0 = argv[0];
5318 VM_ASSERT(argv[0] == arg0);
5324vm_callee_setup_block_arg(rb_execution_context_t *ec,
struct rb_calling_info *calling,
const struct rb_callinfo *ci,
const rb_iseq_t *iseq,
VALUE *argv,
const enum arg_setup_type arg_setup_type)
5326 if (rb_simple_iseq_p(iseq)) {
5327 rb_control_frame_t *cfp = ec->cfp;
5330 CALLER_SETUP_ARG(cfp, calling, ci, ISEQ_BODY(iseq)->param.lead_num);
5332 if (arg_setup_type == arg_setup_block &&
5333 calling->argc == 1 &&
5334 ISEQ_BODY(iseq)->param.flags.has_lead &&
5335 !ISEQ_BODY(iseq)->param.flags.ambiguous_param0 &&
5336 !
NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv))) {
5337 calling->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0);
5340 if (calling->argc != ISEQ_BODY(iseq)->param.lead_num) {
5341 if (arg_setup_type == arg_setup_block) {
5342 if (calling->argc < ISEQ_BODY(iseq)->param.lead_num) {
5344 CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
5345 for (i=calling->argc; i<ISEQ_BODY(iseq)->param.lead_num; i++) argv[i] =
Qnil;
5346 calling->argc = ISEQ_BODY(iseq)->param.lead_num;
5348 else if (calling->argc > ISEQ_BODY(iseq)->param.lead_num) {
5349 calling->argc = ISEQ_BODY(iseq)->param.lead_num;
5353 argument_arity_error(ec, iseq, NULL, calling->argc, ISEQ_BODY(iseq)->param.lead_num, ISEQ_BODY(iseq)->param.lead_num);
5360 return setup_parameters_complex(ec, iseq, calling, ci, argv, arg_setup_type);
5365vm_yield_setup_args(rb_execution_context_t *ec,
const rb_iseq_t *iseq,
const int argc,
VALUE *argv,
int flags,
VALUE block_handler,
enum arg_setup_type arg_setup_type)
5369 calling = &calling_entry;
5370 calling->argc = argc;
5371 calling->block_handler = block_handler;
5372 calling->kw_splat = (flags & VM_CALL_KW_SPLAT) ? 1 : 0;
5374 calling->heap_argv = 0;
5376 struct rb_callinfo dummy_ci = VM_CI_ON_STACK(0, flags, 0, 0);
5378 return vm_callee_setup_block_arg(ec, calling, &dummy_ci, iseq, argv, arg_setup_type);
5384vm_invoke_iseq_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5386 bool is_lambda,
VALUE block_handler)
5389 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
5390 const int arg_size = ISEQ_BODY(iseq)->param.size;
5391 VALUE *
const rsp = GET_SP() - calling->argc;
5392 VALUE *
const argv = rsp;
5393 int opt_pc = vm_callee_setup_block_arg(ec, calling, ci, iseq, argv, is_lambda ? arg_setup_method : arg_setup_block);
5394 int frame_flag = VM_FRAME_MAGIC_BLOCK | (is_lambda ? VM_FRAME_FLAG_LAMBDA : 0);
5398 vm_push_frame(ec, iseq,
5401 VM_GUARDED_PREV_EP(captured->ep), 0,
5402 ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
5404 ISEQ_BODY(iseq)->local_table_size - arg_size, ISEQ_BODY(iseq)->stack_max);
5410vm_invoke_symbol_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5412 MAYBE_UNUSED(
bool is_lambda),
VALUE block_handler)
5414 VALUE symbol = VM_BH_TO_SYMBOL(block_handler);
5415 int flags = vm_ci_flag(ci);
5417 if (UNLIKELY(!(flags & VM_CALL_ARGS_SIMPLE) &&
5418 ((calling->argc == 0) ||
5419 (calling->argc == 1 && (flags & (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT))) ||
5420 (calling->argc == 2 && (flags & VM_CALL_ARGS_SPLAT) && (flags & VM_CALL_KW_SPLAT)) ||
5421 ((flags & VM_CALL_KWARG) && (vm_ci_kwarg(ci)->keyword_len == calling->argc))))) {
5422 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV);
5424 if (UNLIKELY(calling->heap_argv)) {
5425#if VM_ARGC_STACK_MAX < 0
5427 rb_raise(rb_eArgError,
"no receiver given");
5433 reg_cfp->sp[-1] = reg_cfp->sp[-2];
5434 reg_cfp->sp[-2] = calling->recv;
5435 flags |= VM_CALL_ARGS_SPLAT;
5438 if (calling->argc < 1) {
5439 rb_raise(rb_eArgError,
"no receiver given");
5441 calling->recv = TOPN(--calling->argc);
5443 if (calling->kw_splat) {
5444 flags |= VM_CALL_KW_SPLAT;
5448 if (calling->argc < 1) {
5449 rb_raise(rb_eArgError,
"no receiver given");
5451 calling->recv = TOPN(--calling->argc);
5454 return vm_call_symbol(ec, reg_cfp, calling, ci, symbol, flags);
5458vm_invoke_ifunc_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5460 MAYBE_UNUSED(
bool is_lambda),
VALUE block_handler)
5465 CALLER_SETUP_ARG(ec->cfp, calling, ci, ALLOW_HEAP_ARGV_KEEP_KWSPLAT);
5466 argc = calling->argc;
5467 val = vm_yield_with_cfunc(ec, captured, captured->self, CALLING_ARGC(calling), calling->heap_argv ?
RARRAY_CONST_PTR(calling->heap_argv) : STACK_ADDR_FROM_TOP(argc), calling->kw_splat, calling->block_handler, NULL);
5473vm_proc_to_block_handler(
VALUE procval)
5475 const struct rb_block *block = vm_proc_block(procval);
5477 switch (vm_block_type(block)) {
5478 case block_type_iseq:
5479 return VM_BH_FROM_ISEQ_BLOCK(&block->as.captured);
5480 case block_type_ifunc:
5481 return VM_BH_FROM_IFUNC_BLOCK(&block->as.captured);
5482 case block_type_symbol:
5483 return VM_BH_FROM_SYMBOL(block->as.symbol);
5484 case block_type_proc:
5485 return VM_BH_FROM_PROC(block->as.proc);
5487 VM_UNREACHABLE(vm_yield_with_proc);
5492vm_invoke_proc_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5494 bool is_lambda,
VALUE block_handler)
5496 while (vm_block_handler_type(block_handler) == block_handler_type_proc) {
5497 VALUE proc = VM_BH_TO_PROC(block_handler);
5498 is_lambda = block_proc_is_lambda(proc);
5499 block_handler = vm_proc_to_block_handler(proc);
5502 return vm_invoke_block(ec, reg_cfp, calling, ci, is_lambda, block_handler);
5506vm_invoke_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5508 bool is_lambda,
VALUE block_handler)
5510 VALUE (*func)(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5512 bool is_lambda,
VALUE block_handler);
5514 switch (vm_block_handler_type(block_handler)) {
5515 case block_handler_type_iseq: func = vm_invoke_iseq_block;
break;
5516 case block_handler_type_ifunc: func = vm_invoke_ifunc_block;
break;
5517 case block_handler_type_proc: func = vm_invoke_proc_block;
break;
5518 case block_handler_type_symbol: func = vm_invoke_symbol_block;
break;
5519 default: rb_bug(
"vm_invoke_block: unreachable");
5522 return func(ec, reg_cfp, calling, ci, is_lambda, block_handler);
5526vm_make_proc_with_iseq(
const rb_iseq_t *blockiseq)
5528 const rb_execution_context_t *ec = GET_EC();
5529 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
5533 rb_bug(
"vm_make_proc_with_iseq: unreachable");
5536 captured = VM_CFP_TO_CAPTURED_BLOCK(cfp);
5537 captured->code.iseq = blockiseq;
5539 return rb_vm_make_proc(ec, captured,
rb_cProc);
5543vm_once_exec(
VALUE iseq)
5545 VALUE proc = vm_make_proc_with_iseq((rb_iseq_t *)iseq);
5550vm_once_clear(
VALUE data)
5553 is->once.running_thread = NULL;
5565 args[0] = obj; args[1] =
Qfalse;
5567 if (!UNDEF_P(r) &&
RTEST(r)) {
5576vm_defined(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t op_type,
VALUE obj,
VALUE v)
5579 enum defined_type
type = (
enum defined_type)op_type;
5586 return rb_gvar_defined(
SYM2ID(obj));
5588 case DEFINED_CVAR: {
5589 const rb_cref_t *cref = vm_get_cref(GET_EP());
5590 klass = vm_get_cvar_base(cref, GET_CFP(), 0);
5595 case DEFINED_CONST_FROM: {
5596 bool allow_nil =
type == DEFINED_CONST;
5598 return vm_get_ev_const(ec, klass,
SYM2ID(obj), allow_nil,
true);
5603 return rb_ec_obj_respond_to(ec, v,
SYM2ID(obj), TRUE);
5605 case DEFINED_METHOD:{
5607 const rb_callable_method_entry_t *cme = rb_callable_method_entry_with_refinements(klass,
SYM2ID(obj), NULL);
5610 switch (METHOD_ENTRY_VISI(cme)) {
5611 case METHOD_VISI_PRIVATE:
5613 case METHOD_VISI_PROTECTED:
5617 case METHOD_VISI_PUBLIC:
5621 rb_bug(
"vm_defined: unreachable: %u", (
unsigned int)METHOD_ENTRY_VISI(cme));
5625 return check_respond_to_missing(obj, v);
5630 if (GET_BLOCK_HANDLER() != VM_BLOCK_HANDLER_NONE) {
5634 case DEFINED_ZSUPER:
5636 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(GET_CFP());
5639 VALUE klass = vm_search_normal_superclass(me->defined_class);
5640 if (!klass)
return false;
5642 ID id = me->def->original_id;
5649 return RTEST(vm_backref_defined(ec, GET_LEP(),
FIX2INT(obj)));
5651 rb_bug(
"unimplemented defined? type (VM)");
5659rb_vm_defined(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t op_type,
VALUE obj,
VALUE v)
5661 return vm_defined(ec, reg_cfp, op_type, obj, v);
5665vm_get_ep(
const VALUE *
const reg_ep, rb_num_t lv)
5668 const VALUE *ep = reg_ep;
5669 for (i = 0; i < lv; i++) {
5670 ep = GET_PREV_EP(ep);
5676vm_get_special_object(
const VALUE *
const reg_ep,
5677 enum vm_special_object_type
type)
5680 case VM_SPECIAL_OBJECT_VMCORE:
5681 return rb_mRubyVMFrozenCore;
5682 case VM_SPECIAL_OBJECT_CBASE:
5683 return vm_get_cbase(reg_ep);
5684 case VM_SPECIAL_OBJECT_CONST_BASE:
5685 return vm_get_const_base(reg_ep);
5687 rb_bug(
"putspecialobject insn: unknown value_type %d",
type);
5694rb_vm_get_special_object(
const VALUE *reg_ep,
enum vm_special_object_type
type)
5696 return vm_get_special_object(reg_ep,
type);
5702 const VALUE ary2 = ary2st;
5703 VALUE tmp1 = rb_check_to_array(ary1);
5704 VALUE tmp2 = rb_check_to_array(ary2);
5725 const VALUE ary2 = ary2st;
5727 if (
NIL_P(ary2))
return ary1;
5729 VALUE tmp2 = rb_check_to_array(ary2);
5744 return vm_concat_array(ary1, ary2st);
5748rb_vm_concat_to_array(
VALUE ary1,
VALUE ary2st)
5750 return vm_concat_to_array(ary1, ary2st);
5759 VALUE tmp = rb_check_to_array(ary);
5763 else if (
RTEST(flag)) {
5776 return vm_splat_array(flag, ary);
5780vm_check_match(rb_execution_context_t *ec,
VALUE target,
VALUE pattern, rb_num_t flag)
5782 enum vm_check_match_type
type = ((int)flag) & VM_CHECKMATCH_TYPE_MASK;
5784 if (flag & VM_CHECKMATCH_ARRAY) {
5788 for (i = 0; i < n; i++) {
5790 VALUE c = check_match(ec, v, target,
type);
5799 return check_match(ec, pattern, target,
type);
5804rb_vm_check_match(rb_execution_context_t *ec,
VALUE target,
VALUE pattern, rb_num_t flag)
5806 return vm_check_match(ec, target, pattern, flag);
5810vm_check_keyword(lindex_t bits, lindex_t idx,
const VALUE *ep)
5812 const VALUE kw_bits = *(ep - bits);
5815 unsigned int b = (
unsigned int)
FIX2ULONG(kw_bits);
5816 if ((idx < VM_KW_SPECIFIED_BITS_MAX) && (b & (0x01 << idx)))
5820 VM_ASSERT(RB_TYPE_P(kw_bits,
T_HASH));
5829 if (RUBY_DTRACE_METHOD_ENTRY_ENABLED() ||
5830 RUBY_DTRACE_METHOD_RETURN_ENABLED() ||
5831 RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() ||
5832 RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) {
5836 RUBY_DTRACE_METHOD_ENTRY_HOOK(ec, 0, 0);
5839 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, 0, 0);
5842 RUBY_DTRACE_METHOD_RETURN_HOOK(ec, 0, 0);
5845 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, 0, 0);
5852vm_const_get_under(
ID id, rb_num_t flags,
VALUE cbase)
5857 else if (VM_DEFINECLASS_SCOPED_P(flags)) {
5858 return rb_public_const_get_at(cbase,
id);
5866vm_check_if_class(
ID id, rb_num_t flags,
VALUE super,
VALUE klass)
5868 if (!RB_TYPE_P(klass,
T_CLASS)) {
5871 else if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags)) {
5876 "superclass mismatch for class %"PRIsVALUE
"",
5889vm_check_if_module(
ID id,
VALUE mod)
5908vm_declare_class(
ID id, rb_num_t flags,
VALUE cbase,
VALUE super)
5911 VALUE s = VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) ? super : rb_cObject;
5919vm_declare_module(
ID id,
VALUE cbase)
5925NORETURN(
static void unmatched_redefinition(
const char *
type,
VALUE cbase,
ID id,
VALUE old));
5929 VALUE name = rb_id2str(
id);
5930 VALUE message = rb_sprintf(
"%"PRIsVALUE
" is not a %s",
5932 VALUE location = rb_const_source_location_at(cbase,
id);
5933 if (!
NIL_P(location)) {
5934 rb_str_catf(message,
"\n%"PRIsVALUE
":%"PRIsVALUE
":"
5935 " previous definition of %"PRIsVALUE
" was here",
5942vm_define_class(
ID id, rb_num_t flags,
VALUE cbase,
VALUE super)
5946 if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) && !RB_TYPE_P(super,
T_CLASS)) {
5948 "superclass must be an instance of Class (given an instance of %"PRIsVALUE
")",
5952 vm_check_if_namespace(cbase);
5957 if ((klass = vm_const_get_under(
id, flags, cbase)) != 0) {
5958 if (!vm_check_if_class(
id, flags, super, klass))
5959 unmatched_redefinition(
"class", cbase,
id, klass);
5963 return vm_declare_class(
id, flags, cbase, super);
5968vm_define_module(
ID id, rb_num_t flags,
VALUE cbase)
5972 vm_check_if_namespace(cbase);
5973 if ((mod = vm_const_get_under(
id, flags, cbase)) != 0) {
5974 if (!vm_check_if_module(
id, mod))
5975 unmatched_redefinition(
"module", cbase,
id, mod);
5979 return vm_declare_module(
id, cbase);
5984vm_find_or_create_class_by_id(
ID id,
5989 rb_vm_defineclass_type_t
type = VM_DEFINECLASS_TYPE(flags);
5992 case VM_DEFINECLASS_TYPE_CLASS:
5994 return vm_define_class(
id, flags, cbase, super);
5996 case VM_DEFINECLASS_TYPE_SINGLETON_CLASS:
6000 case VM_DEFINECLASS_TYPE_MODULE:
6002 return vm_define_module(
id, flags, cbase);
6005 rb_bug(
"unknown defineclass type: %d", (
int)
type);
6009static rb_method_visibility_t
6010vm_scope_visibility_get(
const rb_execution_context_t *ec)
6012 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
6014 if (!vm_env_cref_by_cref(cfp->ep)) {
6015 return METHOD_VISI_PUBLIC;
6018 return CREF_SCOPE_VISI(vm_ec_cref(ec))->method_visi;
6023vm_scope_module_func_check(
const rb_execution_context_t *ec)
6025 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
6027 if (!vm_env_cref_by_cref(cfp->ep)) {
6031 return CREF_SCOPE_VISI(vm_ec_cref(ec))->module_func;
6036vm_define_method(
const rb_execution_context_t *ec,
VALUE obj,
ID id,
VALUE iseqval,
int is_singleton)
6039 rb_method_visibility_t visi;
6040 rb_cref_t *cref = vm_ec_cref(ec);
6044 visi = METHOD_VISI_PUBLIC;
6047 klass = CREF_CLASS_FOR_DEFINITION(cref);
6048 visi = vm_scope_visibility_get(ec);
6055 rb_add_method_iseq(klass,
id, (
const rb_iseq_t *)iseqval, cref, visi);
6057 if (
id == idInitialize && klass != rb_cObject && RB_TYPE_P(klass,
T_CLASS) && (
rb_get_alloc_func(klass) == rb_class_allocate_instance)) {
6058 RCLASS_SET_MAX_IV_COUNT(klass, rb_estimate_iv_count(klass, (
const rb_iseq_t *)iseqval));
6061 if (!is_singleton && vm_scope_module_func_check(ec)) {
6063 rb_add_method_iseq(klass,
id, (
const rb_iseq_t *)iseqval, cref, METHOD_VISI_PUBLIC);
6072rb_vm_untag_block_handler(
VALUE block_handler)
6074 if (VM_BLOCK_HANDLER_NONE == block_handler)
return Qnil;
6076 switch (vm_block_handler_type(block_handler)) {
6077 case block_handler_type_iseq:
6078 case block_handler_type_ifunc: {
6080 return captured->code.val;
6082 case block_handler_type_proc:
6083 case block_handler_type_symbol:
6084 return block_handler;
6086 rb_bug(
"rb_vm_untag_block_handler: unreachable");
6091rb_vm_get_untagged_block_handler(rb_control_frame_t *reg_cfp)
6093 return rb_vm_untag_block_handler(VM_CF_BLOCK_HANDLER(reg_cfp));
6102 VALUE block_handler = VM_CF_BLOCK_HANDLER(GET_CFP());
6104 if (block_handler == VM_BLOCK_HANDLER_NONE) {
6105 rb_vm_localjump_error(
"no block given (yield)",
Qnil, 0);
6108 return vm_invoke_block(ec, GET_CFP(), calling, ci,
false, block_handler);
6112enum method_explorer_type {
6114 mexp_search_invokeblock,
6123 VALUE block_handler,
6124 enum method_explorer_type method_explorer
6129 int argc = vm_ci_argc(ci);
6130 VALUE recv = TOPN(argc);
6132 .block_handler = block_handler,
6133 .kw_splat = IS_ARGS_KW_SPLAT(ci) > 0,
6139 switch (method_explorer) {
6140 case mexp_search_method:
6141 calling.cc = cc = vm_search_method_fastpath((
VALUE)reg_cfp->iseq, cd,
CLASS_OF(recv));
6142 val = vm_cc_call(cc)(ec, GET_CFP(), &calling);
6144 case mexp_search_super:
6145 calling.cc = cc = vm_search_super_method(reg_cfp, cd, recv);
6146 val = vm_cc_call(cc)(ec, GET_CFP(), &calling);
6148 case mexp_search_invokeblock:
6149 val = vm_invokeblock_i(ec, GET_CFP(), &calling);
6156rb_vm_send(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6159 VALUE bh = vm_caller_setup_arg_block(ec, GET_CFP(), cd->ci, blockiseq,
false);
6160 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_method);
6166rb_vm_sendforward(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6173 VALUE bh = vm_caller_setup_fwd_args(GET_EC(), GET_CFP(), cd, blockiseq,
false, &adjusted_cd, &adjusted_ci);
6175 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd.cd, bh, mexp_search_method);
6177 if (cd->cc != adjusted_cd.cd.cc && vm_cc_markable(adjusted_cd.cd.cc)) {
6186rb_vm_opt_send_without_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd)
6189 VALUE bh = VM_BLOCK_HANDLER_NONE;
6190 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_method);
6196rb_vm_invokesuper(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6200 struct rb_callinfo adjusted_ci = VM_CI_ON_STACK(vm_ci_mid(cd->ci),
6203 vm_ci_kwarg(cd->ci));
6204 const struct rb_callcache *original_cc = rbimpl_atomic_ptr_load((
void **)&cd->cc, RBIMPL_ATOMIC_ACQUIRE);
6210 VALUE bh = vm_caller_setup_arg_block(ec, GET_CFP(), adjusted_cd.ci, blockiseq,
true);
6211 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd, bh, mexp_search_super);
6213 if (original_cc != adjusted_cd.cc && vm_cc_markable(adjusted_cd.cc)) {
6214 rbimpl_atomic_ptr_store((
volatile void **)&cd->cc, (
void *)adjusted_cd.cc, RBIMPL_ATOMIC_RELEASE);
6223rb_vm_invokesuperforward(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6229 VALUE bh = vm_caller_setup_fwd_args(GET_EC(), GET_CFP(), cd, blockiseq,
true, &adjusted_cd, &adjusted_ci);
6231 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd.cd, bh, mexp_search_super);
6233 if (cd->cc != adjusted_cd.cd.cc && vm_cc_markable(adjusted_cd.cd.cc)) {
6242rb_vm_invokeblock(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd)
6245 VALUE bh = VM_BLOCK_HANDLER_NONE;
6246 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_invokeblock);
6263vm_objtostring(
const rb_iseq_t *iseq,
VALUE recv, CALL_DATA cd)
6274 if (check_method_basic_definition(cme)) {
6283 if (check_cfunc(cme, rb_mod_to_s)) {
6289 val = rb_mod_to_s(recv);
6295 if (check_cfunc(cme, rb_nil_to_s)) {
6296 return rb_nil_to_s(recv);
6300 if (check_cfunc(cme, rb_true_to_s)) {
6301 return rb_true_to_s(recv);
6305 if (check_cfunc(cme, rb_false_to_s)) {
6306 return rb_false_to_s(recv);
6310 if (check_cfunc(cme, rb_int_to_s)) {
6311 return rb_fix_to_s(recv);
6321rb_vm_objtostring(
const rb_iseq_t *iseq,
VALUE recv, CALL_DATA cd)
6323 return vm_objtostring(iseq, recv, cd);
6327vm_opt_ary_freeze(
VALUE ary,
int bop,
ID id)
6329 if (BASIC_OP_UNREDEFINED_P(bop, ARRAY_REDEFINED_OP_FLAG)) {
6338vm_opt_hash_freeze(
VALUE hash,
int bop,
ID id)
6340 if (BASIC_OP_UNREDEFINED_P(bop, HASH_REDEFINED_OP_FLAG)) {
6349vm_opt_str_freeze(
VALUE str,
int bop,
ID id)
6351 if (BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
6363vm_opt_duparray_include_p(rb_execution_context_t *ec,
const VALUE ary,
VALUE target)
6365 if (BASIC_OP_UNREDEFINED_P(BOP_INCLUDE_P, ARRAY_REDEFINED_OP_FLAG)) {
6369 VALUE args[1] = {target};
6372 RUBY_DTRACE_CREATE_HOOK(ARRAY,
RARRAY_LEN(ary));
6375 return rb_vm_call_with_refinements(ec, dupary, idIncludeP, 1, args,
RB_NO_KEYWORDS);
6380rb_vm_opt_duparray_include_p(rb_execution_context_t *ec,
const VALUE ary,
VALUE target)
6382 return vm_opt_duparray_include_p(ec, ary, target);
6386vm_opt_newarray_max(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr)
6388 if (BASIC_OP_UNREDEFINED_P(BOP_MAX, ARRAY_REDEFINED_OP_FLAG)) {
6389 if (array_len == 0) {
6394 rb_snum_t i = array_len - 1;
6397 if (OPTIMIZED_CMP(v, result) > 0) {
6410rb_vm_opt_newarray_max(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr)
6412 return vm_opt_newarray_max(ec, array_len,
ptr);
6416vm_opt_newarray_min(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr)
6418 if (BASIC_OP_UNREDEFINED_P(BOP_MIN, ARRAY_REDEFINED_OP_FLAG)) {
6419 if (array_len == 0) {
6424 rb_snum_t i = array_len - 1;
6427 if (OPTIMIZED_CMP(v, result) < 0) {
6440rb_vm_opt_newarray_min(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr)
6442 return vm_opt_newarray_min(ec, array_len,
ptr);
6446vm_opt_newarray_hash(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr)
6449 if (BASIC_OP_UNREDEFINED_P(BOP_HASH, ARRAY_REDEFINED_OP_FLAG)) {
6450 return rb_ary_hash_values(array_len,
ptr);
6458rb_vm_opt_newarray_hash(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr)
6460 return vm_opt_newarray_hash(ec, array_len,
ptr);
6467vm_opt_newarray_include_p(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr,
VALUE target)
6469 if (BASIC_OP_UNREDEFINED_P(BOP_INCLUDE_P, ARRAY_REDEFINED_OP_FLAG)) {
6470 struct RArray fake_ary = {RBASIC_INIT};
6471 VALUE ary = rb_setup_fake_ary(&fake_ary,
ptr, array_len);
6475 VALUE args[1] = {target};
6481rb_vm_opt_newarray_include_p(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr,
VALUE target)
6483 return vm_opt_newarray_include_p(ec, array_len,
ptr, target);
6487vm_opt_newarray_pack_buffer(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr,
VALUE fmt,
VALUE buffer)
6489 if (BASIC_OP_UNREDEFINED_P(BOP_PACK, ARRAY_REDEFINED_OP_FLAG)) {
6490 struct RArray fake_ary = {RBASIC_INIT};
6491 VALUE ary = rb_setup_fake_ary(&fake_ary,
ptr, array_len);
6492 return rb_ec_pack_ary(ec, ary, fmt, (UNDEF_P(buffer) ?
Qnil : buffer));
6502 if (!UNDEF_P(buffer)) {
6503 args[1] = rb_hash_new_with_size(1);
6504 rb_hash_aset(args[1],
ID2SYM(idBuffer), buffer);
6509 return rb_vm_call_with_refinements(ec,
rb_ary_new4(array_len,
ptr), idPack, argc, args, kw_splat);
6514rb_vm_opt_newarray_pack_buffer(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr,
VALUE fmt,
VALUE buffer)
6516 return vm_opt_newarray_pack_buffer(ec, array_len,
ptr, fmt, buffer);
6520rb_vm_opt_newarray_pack(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *
ptr,
VALUE fmt)
6522 return vm_opt_newarray_pack_buffer(ec, array_len,
ptr, fmt,
Qundef);
6528vm_track_constant_cache(
ID id,
void *ic)
6530 rb_vm_t *vm = GET_VM();
6531 struct rb_id_table *const_cache = vm->constant_cache;
6532 VALUE lookup_result;
6535 if (rb_id_table_lookup(const_cache,
id, &lookup_result)) {
6539 ics = set_init_numtable();
6540 rb_id_table_insert(const_cache,
id, (
VALUE)ics);
6555 vm->inserting_constant_cache_id = id;
6557 set_insert(ics, (st_data_t)ic);
6559 vm->inserting_constant_cache_id = (
ID)0;
6563vm_ic_track_const_chain(rb_control_frame_t *cfp, IC ic,
const ID *segments)
6566 for (
int i = 0; segments[i]; i++) {
6567 ID id = segments[i];
6568 if (
id == idNULL)
continue;
6569 vm_track_constant_cache(
id, ic);
6576vm_inlined_ic_hit_p(
VALUE flags,
VALUE value,
const rb_cref_t *ic_cref,
const VALUE *reg_ep)
6578 if ((flags & IMEMO_CONST_CACHE_SHAREABLE) || rb_ractor_main_p()) {
6579 VM_ASSERT(ractor_incidental_shareable_p(flags & IMEMO_CONST_CACHE_SHAREABLE, value));
6581 return (ic_cref == NULL ||
6582 ic_cref == vm_get_cref(reg_ep));
6590 VM_ASSERT(IMEMO_TYPE_P(ice, imemo_constcache));
6591 return vm_inlined_ic_hit_p(ice->flags, ice->value, ice->ic_cref, reg_ep);
6596rb_vm_ic_hit_p(IC ic,
const VALUE *reg_ep)
6598 return ic->entry && vm_ic_hit_p(ic->entry, reg_ep);
6602vm_ic_update(
const rb_iseq_t *iseq, IC ic,
VALUE val,
const VALUE *reg_ep,
const VALUE *pc)
6604 if (ruby_vm_const_missing_count > 0) {
6605 ruby_vm_const_missing_count = 0;
6612 ice->ic_cref = vm_get_const_key_cref(reg_ep);
6614 if (rb_ractor_shareable_p(val)) {
6616 ice->flags |= IMEMO_CONST_CACHE_SHAREABLE;
6620 unsigned pos = (unsigned)(pc - ISEQ_BODY(iseq)->iseq_encoded);
6621 rb_yjit_constant_ic_update(iseq, ic, pos);
6625rb_vm_opt_getconstant_path(rb_execution_context_t *ec, rb_control_frame_t *
const reg_cfp, IC ic)
6631 if (ice && vm_ic_hit_p(ice, GET_EP())) {
6634 VM_ASSERT(val == vm_get_ev_const_chain(ec, segments));
6637 ruby_vm_constant_cache_misses++;
6638 val = vm_get_ev_const_chain(ec, segments);
6639 vm_ic_track_const_chain(GET_CFP(), ic, segments);
6642 vm_ic_update(GET_ISEQ(), ic, val, GET_EP(), GET_PC() - 2);
6648vm_once_dispatch(rb_execution_context_t *ec, ISEQ iseq, ISE is)
6650 rb_thread_t *th = rb_ec_thread_ptr(ec);
6651 rb_thread_t *
const RUNNING_THREAD_ONCE_DONE = (rb_thread_t *)(0x1);
6654 if (is->once.running_thread == RUNNING_THREAD_ONCE_DONE) {
6655 return is->once.value;
6657 else if (is->once.running_thread == NULL) {
6659 is->once.running_thread = th;
6663 if (RB_FL_ABLE(val)) {
6664 RB_OBJ_SET_SHAREABLE(val);
6670 is->once.running_thread = RUNNING_THREAD_ONCE_DONE;
6673 else if (is->once.running_thread == th) {
6675 return vm_once_exec((
VALUE)iseq);
6679 RUBY_VM_CHECK_INTS(ec);
6686vm_case_dispatch(CDHASH hash, OFFSET else_offset,
VALUE key)
6688 switch (OBJ_BUILTIN_TYPE(key)) {
6694 if (BASIC_OP_UNREDEFINED_P(BOP_EQQ,
6695 SYMBOL_REDEFINED_OP_FLAG |
6696 INTEGER_REDEFINED_OP_FLAG |
6697 FLOAT_REDEFINED_OP_FLAG |
6698 NIL_REDEFINED_OP_FLAG |
6699 TRUE_REDEFINED_OP_FLAG |
6700 FALSE_REDEFINED_OP_FLAG |
6701 STRING_REDEFINED_OP_FLAG)) {
6703 if (RB_FLOAT_TYPE_P(key)) {
6705 if (!isinf(kval) && modf(kval, &kval) == 0.0) {
6709 if (rb_hash_stlike_lookup(hash, key, &val)) {
6721 vm_stack_consistency_error(
const rb_execution_context_t *ec,
6722 const rb_control_frame_t *,
6725vm_stack_consistency_error(
const rb_execution_context_t *ec,
6726 const rb_control_frame_t *cfp,
6729 const ptrdiff_t nsp = VM_SP_CNT(ec, cfp->sp);
6730 const ptrdiff_t nbp = VM_SP_CNT(ec, bp);
6731 static const char stack_consistency_error[] =
6732 "Stack consistency error (sp: %"PRIdPTRDIFF
", bp: %"PRIdPTRDIFF
")";
6733#if defined RUBY_DEVEL
6734 VALUE mesg = rb_sprintf(stack_consistency_error, nsp, nbp);
6739 rb_bug(stack_consistency_error, nsp, nbp);
6746 if (FIXNUM_2_P(recv, obj) &&
6747 BASIC_OP_UNREDEFINED_P(BOP_PLUS, INTEGER_REDEFINED_OP_FLAG)) {
6748 return rb_fix_plus_fix(recv, obj);
6750 else if (FLONUM_2_P(recv, obj) &&
6751 BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
6757 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6759 BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
6764 BASIC_OP_UNREDEFINED_P(BOP_PLUS, STRING_REDEFINED_OP_FLAG)) {
6765 return rb_str_opt_plus(recv, obj);
6767 else if (RBASIC_CLASS(recv) ==
rb_cArray &&
6769 BASIC_OP_UNREDEFINED_P(BOP_PLUS, ARRAY_REDEFINED_OP_FLAG)) {
6780 if (FIXNUM_2_P(recv, obj) &&
6781 BASIC_OP_UNREDEFINED_P(BOP_MINUS, INTEGER_REDEFINED_OP_FLAG)) {
6782 return rb_fix_minus_fix(recv, obj);
6784 else if (FLONUM_2_P(recv, obj) &&
6785 BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
6791 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6793 BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
6804 if (FIXNUM_2_P(recv, obj) &&
6805 BASIC_OP_UNREDEFINED_P(BOP_MULT, INTEGER_REDEFINED_OP_FLAG)) {
6806 return rb_fix_mul_fix(recv, obj);
6808 else if (FLONUM_2_P(recv, obj) &&
6809 BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
6815 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6817 BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
6828 if (FIXNUM_2_P(recv, obj) &&
6829 BASIC_OP_UNREDEFINED_P(BOP_DIV, INTEGER_REDEFINED_OP_FLAG)) {
6830 return (
FIX2LONG(obj) == 0) ?
Qundef : rb_fix_div_fix(recv, obj);
6832 else if (FLONUM_2_P(recv, obj) &&
6833 BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
6834 return rb_flo_div_flo(recv, obj);
6839 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6841 BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
6842 return rb_flo_div_flo(recv, obj);
6852 if (FIXNUM_2_P(recv, obj) &&
6853 BASIC_OP_UNREDEFINED_P(BOP_MOD, INTEGER_REDEFINED_OP_FLAG)) {
6854 return (
FIX2LONG(obj) == 0) ?
Qundef : rb_fix_mod_fix(recv, obj);
6856 else if (FLONUM_2_P(recv, obj) &&
6857 BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
6863 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6865 BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
6874vm_opt_neq(
const rb_iseq_t *iseq, CALL_DATA cd, CALL_DATA cd_eq,
VALUE recv,
VALUE obj)
6876 if (vm_method_cfunc_is(iseq, cd, recv, rb_obj_not_equal)) {
6877 VALUE val = opt_equality(iseq, recv, obj, cd_eq);
6879 if (!UNDEF_P(val)) {
6880 return RBOOL(!
RTEST(val));
6890 if (FIXNUM_2_P(recv, obj) &&
6891 BASIC_OP_UNREDEFINED_P(BOP_LT, INTEGER_REDEFINED_OP_FLAG)) {
6894 else if (FLONUM_2_P(recv, obj) &&
6895 BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
6901 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6903 BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
6914 if (FIXNUM_2_P(recv, obj) &&
6915 BASIC_OP_UNREDEFINED_P(BOP_LE, INTEGER_REDEFINED_OP_FLAG)) {
6918 else if (FLONUM_2_P(recv, obj) &&
6919 BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
6925 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6927 BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
6938 if (FIXNUM_2_P(recv, obj) &&
6939 BASIC_OP_UNREDEFINED_P(BOP_GT, INTEGER_REDEFINED_OP_FLAG)) {
6942 else if (FLONUM_2_P(recv, obj) &&
6943 BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
6949 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6951 BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
6962 if (FIXNUM_2_P(recv, obj) &&
6963 BASIC_OP_UNREDEFINED_P(BOP_GE, INTEGER_REDEFINED_OP_FLAG)) {
6966 else if (FLONUM_2_P(recv, obj) &&
6967 BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
6973 else if (RBASIC_CLASS(recv) ==
rb_cFloat &&
6975 BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
6991 BASIC_OP_UNREDEFINED_P(BOP_LTLT, STRING_REDEFINED_OP_FLAG)) {
6992 if (LIKELY(RB_TYPE_P(obj,
T_STRING))) {
6999 else if (RBASIC_CLASS(recv) ==
rb_cArray &&
7000 BASIC_OP_UNREDEFINED_P(BOP_LTLT, ARRAY_REDEFINED_OP_FLAG)) {
7018 BASIC_OP_UNREDEFINED_P(BOP_AND, INTEGER_REDEFINED_OP_FLAG)) {
7029 if (FIXNUM_2_P(recv, obj) &&
7030 BASIC_OP_UNREDEFINED_P(BOP_OR, INTEGER_REDEFINED_OP_FLAG)) {
7042 if (FIXNUM_2_P(recv, obj) &&
7043 BASIC_OP_UNREDEFINED_P(BOP_AREF, INTEGER_REDEFINED_OP_FLAG)) {
7044 return rb_fix_aref(recv, obj);
7048 else if (RBASIC_CLASS(recv) ==
rb_cArray &&
7049 BASIC_OP_UNREDEFINED_P(BOP_AREF, ARRAY_REDEFINED_OP_FLAG)) {
7051 return rb_ary_entry_internal(recv,
FIX2LONG(obj));
7054 return rb_ary_aref1(recv, obj);
7057 else if (RBASIC_CLASS(recv) ==
rb_cHash &&
7058 BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) {
7059 return rb_hash_aref(recv, obj);
7072 else if (RBASIC_CLASS(recv) ==
rb_cArray &&
7073 BASIC_OP_UNREDEFINED_P(BOP_ASET, ARRAY_REDEFINED_OP_FLAG) &&
7078 else if (RBASIC_CLASS(recv) ==
rb_cHash &&
7079 BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) {
7080 rb_hash_aset(recv, obj, set);
7089vm_opt_length(
VALUE recv,
int bop)
7095 BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
7096 if (bop == BOP_EMPTY_P) {
7097 return LONG2NUM(RSTRING_LEN(recv));
7103 else if (RBASIC_CLASS(recv) ==
rb_cArray &&
7104 BASIC_OP_UNREDEFINED_P(bop, ARRAY_REDEFINED_OP_FLAG)) {
7107 else if (RBASIC_CLASS(recv) ==
rb_cHash &&
7108 BASIC_OP_UNREDEFINED_P(bop, HASH_REDEFINED_OP_FLAG)) {
7117vm_opt_empty_p(
VALUE recv)
7119 switch (vm_opt_length(recv, BOP_EMPTY_P)) {
7129vm_opt_nil_p(
const rb_iseq_t *iseq, CALL_DATA cd,
VALUE recv)
7132 BASIC_OP_UNREDEFINED_P(BOP_NIL_P, NIL_REDEFINED_OP_FLAG)) {
7135 else if (vm_method_cfunc_is(iseq, cd, recv, rb_false)) {
7151 case RSHIFT(~0UL, 1):
7154 return rb_uint2big(1UL << (SIZEOF_LONG * CHAR_BIT - 2));
7172vm_opt_succ(
VALUE recv)
7175 BASIC_OP_UNREDEFINED_P(BOP_SUCC, INTEGER_REDEFINED_OP_FLAG)) {
7176 return fix_succ(recv);
7182 BASIC_OP_UNREDEFINED_P(BOP_SUCC, STRING_REDEFINED_OP_FLAG)) {
7191vm_opt_not(
const rb_iseq_t *iseq, CALL_DATA cd,
VALUE recv)
7193 if (vm_method_cfunc_is(iseq, cd, recv, rb_obj_not)) {
7194 return RBOOL(!
RTEST(recv));
7209 BASIC_OP_UNREDEFINED_P(BOP_MATCH, STRING_REDEFINED_OP_FLAG)) {
7213 BASIC_OP_UNREDEFINED_P(BOP_MATCH, REGEXP_REDEFINED_OP_FLAG)) {
7221rb_event_flag_t rb_iseq_event_flags(
const rb_iseq_t *iseq,
size_t pos);
7223NOINLINE(
static void vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp));
7226vm_trace_hook(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
const VALUE *pc,
7228 rb_hook_list_t *global_hooks, rb_hook_list_t *local_hooks,
VALUE val)
7231 VALUE self = GET_SELF();
7233 VM_ASSERT(rb_popcount64((uint64_t)event) == 1);
7235 if (local_hooks) local_hooks->running++;
7237 if (event & global_hooks->events) {
7240 vm_dtrace(event, ec);
7241 rb_exec_event_hook_orig(ec, global_hooks, event, self, 0, 0, 0 , val, 0);
7245 if (local_hooks) local_hooks->running--;
7246 if (local_hooks != NULL) {
7247 if (event & local_hooks->events) {
7250 rb_exec_event_hook_orig(ec, local_hooks, event, self, 0, 0, 0 , val, 0);
7260#define VM_TRACE_HOOK(target_event, val) do { \
7261 if ((pc_events & (target_event)) & enabled_flags) { \
7262 if (local_hooks_cnt > 0) local_hooks = rb_iseq_local_hooks(iseq, r, false); \
7263 vm_trace_hook(ec, reg_cfp, pc, pc_events, (target_event), global_hooks, local_hooks, (val)); \
7268rescue_errinfo(rb_execution_context_t *ec, rb_control_frame_t *cfp)
7270 VM_ASSERT(VM_FRAME_RUBYFRAME_P(cfp));
7271 VM_ASSERT(ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_RESCUE);
7272 return cfp->ep[VM_ENV_INDEX_LAST_LVAR];
7276vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp)
7278 const VALUE *pc = reg_cfp->pc;
7279 rb_ractor_t *r = rb_ec_ractor_ptr(ec);
7280 rb_event_flag_t enabled_flags = r->pub.hooks.events & ISEQ_TRACE_EVENTS;
7283 if (enabled_flags == 0 && rb_ractor_targeted_hooks_cnt(r) == 0) {
7287 const rb_iseq_t *iseq = reg_cfp->iseq;
7288 size_t pos = pc - ISEQ_BODY(iseq)->iseq_encoded;
7290 unsigned int local_hooks_cnt = iseq->aux.exec.local_hooks_cnt;
7291 rb_hook_list_t *local_hooks = NULL;
7292 if (RB_UNLIKELY(local_hooks_cnt > 0)) {
7294 if (st_lookup(rb_ractor_targeted_hooks(r), (st_data_t)iseq, &val)) {
7295 local_hooks = (rb_hook_list_t*)val;
7298 rb_event_flag_t iseq_local_events = local_hooks != NULL ? local_hooks->events : 0;
7300 rb_hook_list_t *bmethod_local_hooks = NULL;
7302 unsigned int bmethod_hooks_cnt = 0;
7303 rb_method_definition_t *bmethod_def = NULL;
7304 const bool bmethod_frame = VM_FRAME_BMETHOD_P(reg_cfp);
7305 enabled_flags |= iseq_local_events;
7307 VM_ASSERT((iseq_local_events & ~ISEQ_TRACE_EVENTS) == 0);
7309 if (bmethod_frame) {
7310 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(reg_cfp);
7311 VM_ASSERT(me->def->type == VM_METHOD_TYPE_BMETHOD);
7312 bmethod_def = me->def;
7313 bmethod_hooks_cnt = me->def->body.bmethod.local_hooks_cnt;
7314 if (RB_UNLIKELY(bmethod_hooks_cnt > 0)) {
7316 if (st_lookup(rb_ractor_targeted_hooks(r), (st_data_t)me->def, &val)) {
7317 bmethod_local_hooks = (rb_hook_list_t*)val;
7319 if (bmethod_local_hooks) {
7320 bmethod_local_events = bmethod_local_hooks->events;
7325 if ((pc_events & enabled_flags) == 0 && !bmethod_frame) {
7329 rb_iseq_trace_set(iseq, vm_event_flags & ISEQ_TRACE_EVENTS);
7337 else if (ec->trace_arg != NULL) {
7342 rb_hook_list_t *global_hooks = rb_ec_ractor_hooks(ec);
7345 rb_event_flag_t bmethod_events = ractor_events | bmethod_local_events;
7348 ruby_debug_printf(
"vm_trace>>%4d (%4x) - %s:%d %s\n",
7351 RSTRING_PTR(rb_iseq_path(iseq)),
7352 (
int)rb_iseq_line_no(iseq, pos),
7353 RSTRING_PTR(rb_iseq_label(iseq)));
7355 VM_ASSERT(reg_cfp->pc == pc);
7356 VM_ASSERT(pc_events != 0);
7366 VM_TRACE_HOOK(RUBY_EVENT_COVERAGE_LINE,
Qundef);
7367 VM_TRACE_HOOK(RUBY_EVENT_COVERAGE_BRANCH,
Qundef);
7373 if (bmethod_hooks_cnt > 0) bmethod_local_hooks = rb_method_def_local_hooks(bmethod_def, r,
false);
7381#if VM_CHECK_MODE > 0
7382NORETURN( NOINLINE( COLDFUNC
7383void rb_vm_canary_is_found_dead(
enum ruby_vminsn_type i,
VALUE c)));
7386Init_vm_stack_canary(
void)
7389 int n = ruby_fill_random_bytes(&vm_stack_canary,
sizeof vm_stack_canary,
false);
7390 vm_stack_canary |= 0x01;
7392 vm_stack_canary_was_born =
true;
7397rb_vm_canary_is_found_dead(
enum ruby_vminsn_type i,
VALUE c)
7401 const char *insn = rb_insns_name(i);
7405 rb_bug(
"dead canary found at %s: %s", insn, str);
7409void Init_vm_stack_canary(
void) { }
7438builtin_invoker0(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7440 typedef VALUE (*rb_invoke_funcptr0_t)(rb_execution_context_t *ec,
VALUE self);
7441 return (*(rb_invoke_funcptr0_t)funcptr)(ec, self);
7445builtin_invoker1(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7447 typedef VALUE (*rb_invoke_funcptr1_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1);
7448 return (*(rb_invoke_funcptr1_t)funcptr)(ec, self, argv[0]);
7452builtin_invoker2(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7454 typedef VALUE (*rb_invoke_funcptr2_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2);
7455 return (*(rb_invoke_funcptr2_t)funcptr)(ec, self, argv[0], argv[1]);
7459builtin_invoker3(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7462 return (*(rb_invoke_funcptr3_t)funcptr)(ec, self, argv[0], argv[1], argv[2]);
7466builtin_invoker4(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7469 return (*(rb_invoke_funcptr4_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3]);
7473builtin_invoker5(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7476 return (*(rb_invoke_funcptr5_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4]);
7480builtin_invoker6(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7483 return (*(rb_invoke_funcptr6_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
7487builtin_invoker7(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7490 return (*(rb_invoke_funcptr7_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
7494builtin_invoker8(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7497 return (*(rb_invoke_funcptr8_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
7501builtin_invoker9(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7503 typedef VALUE (*rb_invoke_funcptr9_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9);
7504 return (*(rb_invoke_funcptr9_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
7508builtin_invoker10(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7510 typedef VALUE (*rb_invoke_funcptr10_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10);
7511 return (*(rb_invoke_funcptr10_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]);
7515builtin_invoker11(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7517 typedef VALUE (*rb_invoke_funcptr11_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11);
7518 return (*(rb_invoke_funcptr11_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]);
7522builtin_invoker12(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7524 typedef VALUE (*rb_invoke_funcptr12_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11,
VALUE v12);
7525 return (*(rb_invoke_funcptr12_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]);
7529builtin_invoker13(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7531 typedef VALUE (*rb_invoke_funcptr13_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11,
VALUE v12,
VALUE v13);
7532 return (*(rb_invoke_funcptr13_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12]);
7536builtin_invoker14(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7538 typedef VALUE (*rb_invoke_funcptr14_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11,
VALUE v12,
VALUE v13,
VALUE v14);
7539 return (*(rb_invoke_funcptr14_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13]);
7543builtin_invoker15(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7545 typedef VALUE (*rb_invoke_funcptr15_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2,
VALUE v3,
VALUE v4,
VALUE v5,
VALUE v6,
VALUE v7,
VALUE v8,
VALUE v9,
VALUE v10,
VALUE v11,
VALUE v12,
VALUE v13,
VALUE v14,
VALUE v15);
7546 return (*(rb_invoke_funcptr15_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14]);
7549typedef VALUE (*builtin_invoker)(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr);
7551static builtin_invoker
7552lookup_builtin_invoker(
int argc)
7554 static const builtin_invoker invokers[] = {
7573 return invokers[argc];
7577invoke_bf(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
const struct rb_builtin_function* bf,
const VALUE *argv)
7579 const bool canary_p = ISEQ_BODY(reg_cfp->iseq)->builtin_attrs & BUILTIN_ATTR_LEAF;
7580 SETUP_CANARY(canary_p);
7581 rb_insn_func_t func_ptr = (rb_insn_func_t)(uintptr_t)bf->func_ptr;
7582 VALUE ret = (*lookup_builtin_invoker(bf->argc))(ec, reg_cfp->self, argv, func_ptr);
7583 CHECK_CANARY(canary_p, BIN(invokebuiltin));
7588vm_invoke_builtin(rb_execution_context_t *ec, rb_control_frame_t *cfp,
const struct rb_builtin_function* bf,
const VALUE *argv)
7590 return invoke_bf(ec, cfp, bf, argv);
7594vm_invoke_builtin_delegate(rb_execution_context_t *ec, rb_control_frame_t *cfp,
const struct rb_builtin_function *bf,
unsigned int start_index)
7597 fputs(
"vm_invoke_builtin_delegate: passing -> ", stderr);
7598 for (
int i=0; i<bf->argc; i++) {
7599 ruby_debug_printf(
":%s ", rb_id2name(ISEQ_BODY(cfp->iseq)->local_table[i+start_index]));
7601 ruby_debug_printf(
"\n" "%s %s(%d):%p\n", RUBY_FUNCTION_NAME_STRING, bf->name, bf->argc,
7602 (
void *)(uintptr_t)bf->func_ptr);
7605 if (bf->argc == 0) {
7606 return invoke_bf(ec, cfp, bf, NULL);
7609 const VALUE *argv = cfp->ep - ISEQ_BODY(cfp->iseq)->local_table_size - VM_ENV_DATA_SIZE + 1 + start_index;
7610 return invoke_bf(ec, cfp, bf, argv);
7617rb_vm_lvar_exposed(rb_execution_context_t *ec,
int index)
7619 const rb_control_frame_t *cfp = ec->cfp;
7620 return cfp->ep[index];
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
#define RUBY_EVENT_END
Encountered an end of a class clause.
#define RUBY_EVENT_C_CALL
A method, written in C, is called.
#define RUBY_EVENT_B_RETURN
Encountered a next statement.
#define RUBY_EVENT_CLASS
Encountered a new class.
#define RUBY_EVENT_LINE
Encountered a new line.
#define RUBY_EVENT_RETURN
Encountered a return statement.
#define RUBY_EVENT_C_RETURN
Return from a method, written in C.
#define RUBY_EVENT_B_CALL
Encountered an yield statement.
uint32_t rb_event_flag_t
Represents event(s).
#define RUBY_EVENT_CALL
A method, written in Ruby, is called.
#define RUBY_EVENT_RESCUE
Encountered a rescue statement.
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
VALUE rb_module_new(void)
Creates a new, anonymous module.
VALUE rb_class_inherited(VALUE super, VALUE klass)
Calls Class::inherited.
VALUE rb_define_class_id(ID id, VALUE super)
This is a very badly designed API that creates an anonymous class.
#define TYPE(_)
Old name of rb_type.
#define RFLOAT_VALUE
Old name of rb_float_value.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define T_NIL
Old name of RUBY_T_NIL.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define T_IMEMO
Old name of RUBY_T_IMEMO.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#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 FIXABLE
Old name of RB_FIXABLE.
#define LONG2FIX
Old name of RB_INT2FIX.
#define FIX2INT
Old name of RB_FIX2INT.
#define T_MODULE
Old name of RUBY_T_MODULE.
#define STATIC_SYM_P
Old name of RB_STATIC_SYM_P.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define FIX2ULONG
Old name of RB_FIX2ULONG.
#define T_TRUE
Old name of RUBY_T_TRUE.
#define T_ICLASS
Old name of RUBY_T_ICLASS.
#define T_HASH
Old name of RUBY_T_HASH.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define rb_exc_new3
Old name of rb_exc_new_str.
#define T_FALSE
Old name of RUBY_T_FALSE.
#define Qtrue
Old name of RUBY_Qtrue.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define T_OBJECT
Old name of RUBY_T_OBJECT.
#define NIL_P
Old name of RB_NIL_P.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define DBL2NUM
Old name of rb_float_new.
#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 FIXNUM_P
Old name of RB_FIXNUM_P.
#define FL_USHIFT
Old name of RUBY_FL_USHIFT.
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
void rb_notimplement(void)
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eFatal
fatal exception.
VALUE rb_eNoMethodError
NoMethodError exception.
void rb_exc_fatal(VALUE mesg)
Raises a fatal error in the current thread.
VALUE rb_eRuntimeError
RuntimeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
void rb_error_frozen_object(VALUE frozen_obj)
Identical to rb_error_frozen(), except it takes arbitrary Ruby object instead of C's string.
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_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
@ RB_WARN_CATEGORY_STRICT_UNUSED_BLOCK
Warning is for checking unused block strictly.
VALUE rb_cClass
Class class.
VALUE rb_cArray
Array class.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
VALUE rb_cRegexp
Regexp class.
VALUE rb_obj_frozen_p(VALUE obj)
Just calls RB_OBJ_FROZEN() inside.
VALUE rb_cHash
Hash class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_cModule
Module class.
VALUE rb_class_real(VALUE klass)
Finds a "real" class.
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
VALUE rb_cFloat
Float class.
VALUE rb_cProc
Proc 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.
VALUE rb_ary_concat(VALUE lhs, VALUE rhs)
Destructively appends the contents of latter into the end of former.
VALUE rb_ary_shift(VALUE ary)
Destructively deletes an element from the beginning of the passed array and returns what was deleted.
VALUE rb_ary_resurrect(VALUE ary)
I guess there is no use case of this function in extension libraries, but this is a routine identical...
VALUE rb_ary_dup(VALUE ary)
Duplicates an array.
VALUE rb_ary_includes(VALUE ary, VALUE elem)
Queries if the passed array has the passed entry.
VALUE rb_ary_plus(VALUE lhs, VALUE rhs)
Creates a new array, concatenating the former to the latter.
VALUE rb_ary_cat(VALUE ary, const VALUE *train, long len)
Destructively appends multiple elements at the end of the array.
VALUE rb_check_array_type(VALUE obj)
Try converting an object to its array representation using its to_ary method, if any.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_pop(VALUE ary)
Destructively deletes an element from the end of the passed array and returns what was deleted.
VALUE rb_ary_hidden_new(long capa)
Allocates a hidden (no class) empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
void rb_ary_store(VALUE ary, long key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
VALUE rb_proc_call_with_block(VALUE recv, int argc, const VALUE *argv, VALUE proc)
Identical to rb_proc_call(), except you can additionally pass another proc object,...
VALUE rb_reg_last_match(VALUE md)
This just returns the argument, stringified.
VALUE rb_reg_match(VALUE re, VALUE str)
This is the match operator.
VALUE rb_reg_nth_match(int n, VALUE md)
Queries the nth captured substring.
VALUE rb_reg_match_post(VALUE md)
The portion of the original string after the given match.
VALUE rb_reg_nth_defined(int n, VALUE md)
Identical to rb_reg_nth_match(), except it just returns Boolean.
VALUE rb_reg_match_pre(VALUE md)
The portion of the original string before the given match.
VALUE rb_reg_match_last(VALUE md)
The portion of the original string that captured at the very last.
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_succ(VALUE orig)
Searches for the "successor" of a string.
VALUE rb_str_buf_append(VALUE dst, VALUE src)
Identical to rb_str_cat_cstr(), except it takes Ruby's string instead of C's.
VALUE rb_str_concat(VALUE dst, VALUE src)
Identical to rb_str_append(), except it also accepts an integer as a codepoint.
#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_str_length(VALUE)
Identical to rb_str_strlen(), except it returns the value in rb_cInteger.
VALUE rb_str_intern(VALUE str)
Identical to rb_to_symbol(), except it assumes the receiver being an instance of RString.
void rb_thread_schedule(void)
Tries to switch to another thread.
VALUE rb_const_get(VALUE space, ID name)
Identical to rb_const_defined(), except it returns the actual defined value.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
void rb_cvar_set(VALUE klass, ID name, VALUE val)
Assigns a value to a class variable.
VALUE rb_cvar_find(VALUE klass, ID name, VALUE *front)
Identical to rb_cvar_get(), except it takes additional "front" pointer.
VALUE rb_ivar_get(VALUE obj, ID name)
Identical to rb_iv_get(), except it accepts the name as an ID instead of a C string.
void rb_const_set(VALUE space, ID name, VALUE val)
Names a constant.
VALUE rb_autoload_load(VALUE space, ID name)
Kicks the autoload procedure as if it was "touched".
VALUE rb_mod_name(VALUE mod)
Queries the name of a module.
VALUE rb_const_get_at(VALUE space, ID name)
Identical to rb_const_defined_at(), except it returns the actual defined value.
void rb_set_class_path_string(VALUE klass, VALUE space, VALUE name)
Identical to rb_set_class_path(), except it accepts the name as Ruby's string instead of C's.
VALUE rb_ivar_defined(VALUE obj, ID name)
Queries if the instance variable is defined at the object.
int rb_const_defined_at(VALUE space, ID name)
Identical to rb_const_defined(), except it doesn't look for parent classes.
VALUE rb_cvar_defined(VALUE klass, ID name)
Queries if the given class has the given class variable.
VALUE rb_class_path(VALUE mod)
Identical to rb_mod_name(), except it returns #<Class: ...> style inspection for anonymous modules.
int rb_const_defined(VALUE space, ID name)
Queries if the constant is defined at the namespace.
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
rb_alloc_func_t rb_get_alloc_func(VALUE klass)
Queries the allocator function of a class.
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
int rb_method_boundp(VALUE klass, ID id, int ex)
Queries if the klass has this method.
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
int off
Offset inside of ptr.
int len
Length of the buffer.
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define ALLOCA_N(type, n)
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define MEMMOVE(p1, p2, type, n)
Handy macro to call memmove.
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 RCLASS_SUPER
Just another name of rb_class_get_superclass.
#define RHASH_SIZE(h)
Queries the size of the hash.
#define RHASH_EMPTY_P(h)
Checks if the hash is empty.
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
#define RB_PASS_KEYWORDS
Pass keywords, final argument should be a hash of keywords.
#define RB_NO_KEYWORDS
Do not pass keywords.
#define RTEST
This is an old name of RB_TEST.
#define ANYARGS
Functions declared using this macro take arbitrary arguments, including void.
const ID * segments
A null-terminated list of ids, used to represent a constant's path idNULL is used to represent the ::...
IFUNC (Internal FUNCtion).
const VALUE cref_or_me
class reference or rb_method_entry_t
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
uintptr_t VALUE
Type that represents a Ruby object.