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/ractor.h"
28#include "internal/random.h"
29#include "internal/variable.h"
30#include "internal/set.h"
31#include "internal/set_table.h"
32#include "internal/struct.h"
38#include "insns_info.inc"
40extern rb_method_definition_t *rb_method_definition_create(rb_method_type_t
type,
ID mid);
41extern void rb_method_definition_set(
const rb_method_entry_t *me, rb_method_definition_t *def,
void *opts);
42extern int rb_method_definition_eq(
const rb_method_definition_t *d1,
const rb_method_definition_t *d2);
44 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;
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;
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 ||
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 (! VM_FRAME_RUBYFRAME_P(reg_cfp) || ! (iseq = GET_ISEQ())) {
270 else if (LIKELY(sp[0] != vm_stack_canary)) {
279 const VALUE *orig = rb_iseq_original_iseq(iseq);
280 const VALUE iseqw = rb_iseqw_new(iseq);
282 const char *stri = rb_str_to_cstr(inspection);
283 const VALUE disasm = rb_iseq_disasm(iseq);
284 const char *strd = rb_str_to_cstr(disasm);
285 const ptrdiff_t pos = previous_insn_index(iseq, GET_PC());
286 const enum ruby_vminsn_type insn = (
enum ruby_vminsn_type)orig[pos];
287 const char *name = insn_name(insn);
293 "We are killing the stack canary set by %s, "
294 "at %s@pc=%"PRIdPTR
"\n"
295 "watch out the C stack trace.\n"
297 name, stri, pos, strd);
298 rb_bug(
"see above.");
300#define vm_check_canary(ec, sp) rb_vm_check_canary(ec, sp)
303#define vm_check_canary(ec, sp)
304#define vm_check_frame(a, b, c, d)
309vm_push_frame_debug_counter_inc(
316 RB_DEBUG_COUNTER_INC(frame_push);
318 if (RUBY_VM_END_CONTROL_FRAME(ec) != prev_cfp) {
319 const bool curr = VM_FRAME_RUBYFRAME_P(reg_cfp);
320 const bool prev = VM_FRAME_RUBYFRAME_P(prev_cfp);
323 RB_DEBUG_COUNTER_INC(frame_R2R);
326 RB_DEBUG_COUNTER_INC(frame_R2C);
331 RB_DEBUG_COUNTER_INC(frame_C2R);
334 RB_DEBUG_COUNTER_INC(frame_C2C);
339 switch (
type & VM_FRAME_MAGIC_MASK) {
340 case VM_FRAME_MAGIC_METHOD: RB_DEBUG_COUNTER_INC(frame_push_method);
return;
341 case VM_FRAME_MAGIC_BLOCK: RB_DEBUG_COUNTER_INC(frame_push_block);
return;
342 case VM_FRAME_MAGIC_CLASS: RB_DEBUG_COUNTER_INC(frame_push_class);
return;
343 case VM_FRAME_MAGIC_TOP: RB_DEBUG_COUNTER_INC(frame_push_top);
return;
344 case VM_FRAME_MAGIC_CFUNC: RB_DEBUG_COUNTER_INC(frame_push_cfunc);
return;
345 case VM_FRAME_MAGIC_IFUNC: RB_DEBUG_COUNTER_INC(frame_push_ifunc);
return;
346 case VM_FRAME_MAGIC_EVAL: RB_DEBUG_COUNTER_INC(frame_push_eval);
return;
347 case VM_FRAME_MAGIC_RESCUE: RB_DEBUG_COUNTER_INC(frame_push_rescue);
return;
348 case VM_FRAME_MAGIC_DUMMY: RB_DEBUG_COUNTER_INC(frame_push_dummy);
return;
351 rb_bug(
"unreachable");
354#define vm_push_frame_debug_counter_inc(ec, cfp, t)
359rb_vm_stack_canary(
void)
362 return vm_stack_canary;
368STATIC_ASSERT(VM_ENV_DATA_INDEX_ME_CREF, VM_ENV_DATA_INDEX_ME_CREF == -2);
369STATIC_ASSERT(VM_ENV_DATA_INDEX_SPECVAL, VM_ENV_DATA_INDEX_SPECVAL == -1);
370STATIC_ASSERT(VM_ENV_DATA_INDEX_FLAGS, VM_ENV_DATA_INDEX_FLAGS == -0);
373vm_push_frame(rb_execution_context_t *ec,
374 const rb_iseq_t *iseq,
384 rb_control_frame_t *
const cfp = RUBY_VM_NEXT_CONTROL_FRAME(ec->cfp);
386 vm_check_frame(
type, specval, cref_or_me, iseq);
387 VM_ASSERT(local_size >= 0);
390 CHECK_VM_STACK_OVERFLOW0(cfp, sp, local_size + stack_max);
391 vm_check_canary(ec, sp);
396 for (
int i=0; i < local_size; i++) {
423 #if defined HAVE_DECL_ATOMIC_SIGNAL_FENCE && HAVE_DECL_ATOMIC_SIGNAL_FENCE
424 atomic_signal_fence(memory_order_seq_cst);
432 vm_push_frame_debug_counter_inc(ec, cfp,
type);
436rb_vm_pop_frame_no_int(rb_execution_context_t *ec)
438 rb_control_frame_t *cfp = ec->cfp;
440 if (VMDEBUG == 2) SDR();
442 ec->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
447vm_pop_frame(rb_execution_context_t *ec, rb_control_frame_t *cfp,
const VALUE *ep)
449 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
451 if (VMDEBUG == 2) SDR();
453 RUBY_VM_CHECK_INTS(ec);
454 ec->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
456 return flags & VM_FRAME_FLAG_FINISH;
460rb_vm_pop_frame(rb_execution_context_t *ec)
462 vm_pop_frame(ec, ec->cfp, ec->cfp->ep);
467rb_vm_push_frame_fname(rb_execution_context_t *ec,
VALUE fname)
469 rb_iseq_t *rb_iseq_alloc_with_dummy_path(
VALUE fname);
470 rb_iseq_t *dmy_iseq = rb_iseq_alloc_with_dummy_path(fname);
474 VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH,
476 VM_BLOCK_HANDLER_NONE,
483 return (
VALUE)dmy_iseq;
488rb_arity_error_new(
int argc,
int min,
int max)
490 VALUE err_mess = rb_sprintf(
"wrong number of arguments (given %d, expected %d", argc, min);
498 rb_str_catf(err_mess,
"..%d", max);
505rb_error_arity(
int argc,
int min,
int max)
512NOINLINE(
static void vm_env_write_slowpath(
const VALUE *ep,
int index,
VALUE v));
515vm_env_write_slowpath(
const VALUE *ep,
int index,
VALUE v)
517 const VALUE envval = VM_ENV_ENVVAL(ep);
524 rb_gc_writebarrier(envval, v);
526 VM_FORCE_WRITE(&ep[index], v);
530 rb_gc_writebarrier_remember(envval);
531 VM_FORCE_WRITE(&ep[index], v);
532 VM_ENV_FLAGS_UNSET(ep, VM_ENV_FLAG_WB_REQUIRED);
534 RB_DEBUG_COUNTER_INC(lvar_set_slowpath);
539vm_env_write(
const VALUE *ep,
int index,
VALUE v)
541 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
542 if (LIKELY((flags & VM_ENV_FLAG_WB_REQUIRED) == 0)) {
543 VM_STACK_ENV_WRITE(ep, index, v);
546 vm_env_write_slowpath(ep, index, v);
551rb_vm_env_write(
const VALUE *ep,
int index,
VALUE v)
553 vm_env_write(ep, index, v);
557rb_vm_bh_to_procval(
const rb_execution_context_t *ec,
VALUE block_handler)
559 if (block_handler == VM_BLOCK_HANDLER_NONE) {
563 switch (vm_block_handler_type(block_handler)) {
564 case block_handler_type_iseq:
565 case block_handler_type_ifunc:
566 return rb_vm_make_proc(ec, VM_BH_TO_CAPT_BLOCK(block_handler),
rb_cProc);
567 case block_handler_type_symbol:
568 return rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
569 case block_handler_type_proc:
570 return VM_BH_TO_PROC(block_handler);
572 VM_UNREACHABLE(rb_vm_bh_to_procval);
581vm_svar_valid_p(
VALUE svar)
584 switch (imemo_type(svar)) {
593 rb_bug(
"vm_svar_valid_p: unknown type: %s", rb_obj_info(svar));
602lep_svar_in_env_p(
const rb_execution_context_t *ec,
const VALUE *lep)
604 if (!lep)
return false;
605 if (ec == NULL)
return true;
606 if (ec->root_lep == lep)
return false;
610 if (
FIXNUM_P(lep[VM_ENV_DATA_INDEX_FLAGS]) &&
611 VM_ENV_ESCAPED_P(lep) &&
619lep_svar(
const rb_execution_context_t *ec,
const VALUE *lep)
623 if (lep_svar_in_env_p(ec, lep)) {
624 svar = lep[VM_ENV_DATA_INDEX_ME_CREF];
627 svar = ec->root_svar;
630 VM_ASSERT(svar ==
Qfalse || vm_svar_valid_p(svar));
636lep_svar_write(
const rb_execution_context_t *ec,
const VALUE *lep,
const struct vm_svar *svar)
638 VM_ASSERT(vm_svar_valid_p((
VALUE)svar));
640 if (lep_svar_in_env_p(ec, lep)) {
641 vm_env_write(lep, VM_ENV_DATA_INDEX_ME_CREF, (
VALUE)svar);
644 RB_OBJ_WRITE(rb_ec_thread_ptr(ec)->self, &ec->root_svar, svar);
649lep_svar_get(
const rb_execution_context_t *ec,
const VALUE *lep, rb_num_t key)
651 const struct vm_svar *svar = lep_svar(ec, lep);
656 case VM_SVAR_LASTLINE:
657 return svar->lastline;
658 case VM_SVAR_BACKREF:
659 return svar->backref;
661 const VALUE ary = svar->others;
676 struct vm_svar *svar = IMEMO_NEW(
struct vm_svar, imemo_svar, obj);
685lep_svar_set(
const rb_execution_context_t *ec,
const VALUE *lep, rb_num_t key,
VALUE val)
687 struct vm_svar *svar = lep_svar(ec, lep);
690 lep_svar_write(ec, lep, svar = svar_new((
VALUE)svar));
694 case VM_SVAR_LASTLINE:
697 case VM_SVAR_BACKREF:
701 VALUE ary = svar->others;
712vm_getspecial(
const rb_execution_context_t *ec,
const VALUE *lep, rb_num_t key, rb_num_t
type)
717 val = lep_svar_get(ec, lep, key);
720 VALUE backref = lep_svar_get(ec, lep, VM_SVAR_BACKREF);
737 rb_bug(
"unexpected back-ref");
748vm_backref_defined(
const rb_execution_context_t *ec,
const VALUE *lep, rb_num_t
type)
750 VALUE backref = lep_svar_get(ec, lep, VM_SVAR_BACKREF);
760 return rb_reg_last_defined(backref);
762 rb_bug(
"unexpected back-ref");
766 nth = (int)(
type >> 1);
771PUREFUNC(
static rb_callable_method_entry_t *check_method_entry(
VALUE obj,
int can_be_svar));
772static rb_callable_method_entry_t *
773check_method_entry(
VALUE obj,
int can_be_svar)
775 if (obj ==
Qfalse)
return NULL;
778 if (!
RB_TYPE_P(obj,
T_IMEMO)) rb_bug(
"check_method_entry: unknown type: %s", rb_obj_info(obj));
781 switch (imemo_type(obj)) {
783 return (rb_callable_method_entry_t *)obj;
792 rb_bug(
"check_method_entry: svar should not be there:");
798static rb_callable_method_entry_t *
799env_method_entry_unchecked(
VALUE obj,
int can_be_svar)
801 if (obj ==
Qfalse)
return NULL;
803 switch (imemo_type(obj)) {
805 return (rb_callable_method_entry_t *)obj;
817const rb_callable_method_entry_t *
818rb_vm_frame_method_entry(
const rb_control_frame_t *cfp)
820 const VALUE *ep = cfp->ep;
821 rb_callable_method_entry_t *me;
823 while (!VM_ENV_LOCAL_P(ep)) {
824 if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL)
return me;
825 ep = VM_ENV_PREV_EP(ep);
828 return check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
831const rb_callable_method_entry_t *
832rb_vm_frame_method_entry_unchecked(
const rb_control_frame_t *cfp)
834 const VALUE *ep = cfp->ep;
835 rb_callable_method_entry_t *me;
837 while (!VM_ENV_LOCAL_P_UNCHECKED(ep)) {
838 if ((me = env_method_entry_unchecked(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL)
return me;
839 ep = VM_ENV_PREV_EP_UNCHECKED(ep);
842 return env_method_entry_unchecked(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
845static const rb_iseq_t *
846method_entry_iseqptr(
const rb_callable_method_entry_t *me)
848 switch (me->def->type) {
849 case VM_METHOD_TYPE_ISEQ:
850 return me->def->body.iseq.
iseqptr;
857method_entry_cref(
const rb_callable_method_entry_t *me)
859 switch (me->def->type) {
860 case VM_METHOD_TYPE_ISEQ:
861 return me->def->body.iseq.
cref;
867#if VM_CHECK_MODE == 0
868PUREFUNC(
static rb_cref_t *check_cref(
VALUE,
int));
871check_cref(
VALUE obj,
int can_be_svar)
873 if (obj ==
Qfalse)
return NULL;
876 if (!
RB_TYPE_P(obj,
T_IMEMO)) rb_bug(
"check_cref: unknown type: %s", rb_obj_info(obj));
879 switch (imemo_type(obj)) {
881 return method_entry_cref((rb_callable_method_entry_t *)obj);
883 return (rb_cref_t *)obj;
890 rb_bug(
"check_method_entry: svar should not be there:");
896static inline rb_cref_t *
897vm_env_cref(
const VALUE *ep)
901 while (!VM_ENV_LOCAL_P(ep)) {
902 if ((cref = check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL)
return cref;
903 ep = VM_ENV_PREV_EP(ep);
906 return check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
910is_cref(
const VALUE v,
int can_be_svar)
913 switch (imemo_type(v)) {
926vm_env_cref_by_cref(
const VALUE *ep)
928 while (!VM_ENV_LOCAL_P(ep)) {
929 if (is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE))
return TRUE;
930 ep = VM_ENV_PREV_EP(ep);
932 return is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
936cref_replace_with_duplicated_cref_each_frame(
const VALUE *vptr,
int can_be_svar,
VALUE parent)
938 const VALUE v = *vptr;
939 rb_cref_t *cref, *new_cref;
942 switch (imemo_type(v)) {
944 cref = (rb_cref_t *)v;
945 new_cref = rb_vm_cref_dup(cref);
950 VM_FORCE_WRITE(vptr, (
VALUE)new_cref);
952 return (rb_cref_t *)new_cref;
955 return cref_replace_with_duplicated_cref_each_frame(&((
struct vm_svar *)v)->
cref_or_me, FALSE, v);
959 rb_bug(
"cref_replace_with_duplicated_cref_each_frame: unreachable");
968vm_cref_replace_with_duplicated_cref(
const VALUE *ep)
970 if (vm_env_cref_by_cref(ep)) {
974 while (!VM_ENV_LOCAL_P(ep)) {
975 envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) :
Qfalse;
976 if ((cref = cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE, envval)) != NULL) {
979 ep = VM_ENV_PREV_EP(ep);
981 envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) :
Qfalse;
982 return cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE, envval);
985 rb_bug(
"vm_cref_dup: unreachable");
990vm_get_cref(
const VALUE *ep)
992 rb_cref_t *cref = vm_env_cref(ep);
998 rb_bug(
"vm_get_cref: unreachable");
1003rb_vm_get_cref(
const VALUE *ep)
1005 return vm_get_cref(ep);
1009vm_ec_cref(
const rb_execution_context_t *ec)
1011 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
1016 return vm_get_cref(cfp->ep);
1019static const rb_cref_t *
1020vm_get_const_key_cref(
const VALUE *ep)
1022 const rb_cref_t *cref = vm_get_cref(ep);
1023 const rb_cref_t *key_cref = cref;
1026 if (CREF_DYNAMIC(cref)) {
1029 cref = CREF_NEXT(cref);
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)
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 entry, *ce = &entry;
1129 if (rb_const_lookup_copy(klass,
id, ce)) {
1132 if (!is_defined && !UNDEF_P(val) && UNLIKELY(!rb_class_owned_p(klass)) &&
1133 !rb_class_field_shareable_p(klass, val)) {
1134 rb_const_warn_if_deprecated(ce, klass,
id);
1135 rb_const_unshareable_error(klass,
id);
1137 rb_const_warn_if_deprecated(ce, klass,
id);
1139 if (am == klass)
break;
1141 if (is_defined)
return 1;
1142 if (rb_autoloading_value(klass,
id, &av, NULL)) {
1143 if (UNLIKELY(!rb_class_owned_p(klass)) && !rb_class_field_shareable_p(klass, av)) {
1144 rb_const_unshareable_error(klass,
id);
1149 goto search_continue;
1164 if (root_cref && !
NIL_P(CREF_CLASS(root_cref))) {
1165 klass = vm_get_iclass(ec->cfp, CREF_CLASS(root_cref));
1179 vm_check_if_namespace(orig_klass);
1181 return rb_public_const_defined_from(orig_klass,
id);
1184 return rb_public_const_get_from(orig_klass,
id);
1190rb_vm_get_ev_const(rb_execution_context_t *ec,
VALUE orig_klass,
ID id,
VALUE allow_nil)
1192 return vm_get_ev_const(ec, orig_klass,
id, allow_nil ==
Qtrue, 0);
1196vm_get_ev_const_chain(rb_execution_context_t *ec,
const ID *segments)
1200 int allow_nil = TRUE;
1201 if (segments[0] == idNULL) {
1206 while (segments[idx]) {
1207 ID id = segments[idx++];
1208 val = vm_get_ev_const(ec, val,
id, allow_nil, 0);
1216vm_get_cvar_base(
const rb_cref_t *cref,
const rb_control_frame_t *cfp,
int top_level_raise)
1221 rb_bug(
"vm_get_cvar_base: no cref");
1224 while (CREF_NEXT(cref) &&
1225 (
NIL_P(CREF_CLASS(cref)) || RCLASS_SINGLETON_P(CREF_CLASS(cref)) ||
1226 CREF_PUSHED_BY_EVAL(cref) || CREF_SINGLETON(cref))) {
1227 cref = CREF_NEXT(cref);
1229 if (top_level_raise && !CREF_NEXT(cref)) {
1233 klass = vm_get_iclass(cfp, CREF_CLASS(cref));
1241#define ractor_incidental_shareable_p(cond, val) \
1242 (!(cond) || rb_ractor_shareable_p(val))
1243#define ractor_object_incidental_shareable_p(obj, val) \
1244 ractor_incidental_shareable_p(rb_ractor_shareable_p(obj), val)
1248vm_getivar(
VALUE obj,
ID id,
const rb_iseq_t *iseq, IVC ic,
const struct rb_callcache *cc,
int is_attr,
VALUE default_value)
1253 return default_value;
1258 fields_obj = ROBJECT_FIELDS_OBJ(obj);
1263 if (UNLIKELY(!rb_class_owned_p(obj))) {
1271 if (default_value ==
Qundef) {
1279 fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
1283 fields_obj = rb_obj_fields(obj,
id);
1287 return default_value;
1292 shape_id_t shape_id = RBASIC_SHAPE_ID_FOR_READ(fields_obj);
1293 VALUE *ivar_list = rb_imemo_fields_ptr(fields_obj);
1295 rb_getivar_cache cache = rb_getivar_cache_unpack(vm_cache_attr_index_atomic_read(is_attr, ic, cc));
1297 if (LIKELY(cache.shape_offset == shape_id)) {
1298 if (cache.index == ATTR_INDEX_NOT_SET) {
1299 return default_value;
1302 val = ivar_list[cache.index];
1303#if USE_DEBUG_COUNTER
1304 RB_DEBUG_COUNTER_INC(ivar_get_ic_hit);
1307 RB_DEBUG_COUNTER_INC(ivar_get_obj_hit);
1313#if USE_DEBUG_COUNTER
1315 if (cache.shape_offset != INVALID_SHAPE_ID) {
1316 RB_DEBUG_COUNTER_INC(ivar_get_cc_miss_set);
1319 RB_DEBUG_COUNTER_INC(ivar_get_cc_miss_unset);
1323 if (cache.shape_offset != INVALID_SHAPE_ID) {
1324 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss_set);
1327 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss_unset);
1330 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss);
1333 RB_DEBUG_COUNTER_INC(ivar_get_obj_miss);
1337 if (UNLIKELY(rb_shape_complex_p(shape_id))) {
1338 st_table *table = (st_table *)ivar_list;
1341 RUBY_ASSERT(table == rb_imemo_fields_complex_tbl(fields_obj));
1343 if (!st_lookup(table,
id, &val)) {
1344 val = default_value;
1348 shape_id_t previous_cached_offset = cache.shape_offset;
1349 if (rb_shape_get_iv_index_with_hint(shape_id,
id, &cache.index, &cache.shape_offset)) {
1350 if (cache.shape_offset != previous_cached_offset) {
1351 RUBY_ASSERT(!rb_shape_complex_p(cache.shape_offset));
1352 RUBY_ASSERT(cache.shape_offset != INVALID_SHAPE_ID);
1354 uint64_t packed_cache = rb_getivar_cache_pack(cache.shape_offset, cache.index);
1355 vm_cache_attr_index_set(is_attr, ic, cc, packed_cache);
1358 if (cache.index == ATTR_INDEX_NOT_SET) {
1359 val = default_value;
1363 val = ivar_list[cache.index];
1368 vm_cache_attr_index_set(is_attr, ic, cc, rb_getivar_cache_pack(shape_id, ATTR_INDEX_NOT_SET));
1369 val = default_value;
1374 if (!UNDEF_P(default_value)) {
1382 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss);
1385 return rb_attr_get(obj,
id);
1392ALWAYS_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));
1393NOINLINE(
static VALUE vm_setivar_slowpath_ivar(
VALUE obj,
ID id,
VALUE val,
const rb_iseq_t *iseq, IVC ic));
1397vm_setivar_slowpath(
VALUE obj,
ID id,
VALUE val,
const rb_iseq_t *iseq, IVC ic,
const struct rb_callcache *cc,
int is_attr)
1400 RB_DEBUG_COUNTER_INC(ivar_set_ic_miss);
1402 rb_check_ivar_modifiable(obj);
1404 shape_id_t previous_shape_id = RBASIC_SHAPE_ID(obj);
1405 attr_index_t index = rb_ivar_set_index(obj,
id, val);
1406 shape_id_t next_shape_id = RBASIC_SHAPE_ID(obj);
1408 if (!rb_shape_complex_p(next_shape_id)) {
1409 uint64_t packed_cache = rb_setivar_cache_pack(RSHAPE_OFFSET(previous_shape_id), RSHAPE_OFFSET(next_shape_id), index);
1410 vm_cache_attr_index_set(is_attr, ic, cc, packed_cache);
1413 RB_DEBUG_COUNTER_INC(ivar_set_obj_miss);
1421vm_setivar_slowpath_ivar(
VALUE obj,
ID id,
VALUE val,
const rb_iseq_t *iseq, IVC ic)
1423 return vm_setivar_slowpath(obj,
id, val, iseq, ic, NULL,
false);
1429 return vm_setivar_slowpath(obj,
id, val, NULL, NULL, cc,
true);
1436 if (UNLIKELY(!rb_class_owned_p(obj))) {
1440 VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
1441 if (UNLIKELY(!fields_obj)) {
1445 shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);
1446 shape_id_t dest_shape_id = rb_setivar_cache_revalidate(shape_id, RBASIC_SHAPE_ID(fields_obj), cache);
1447 if (UNLIKELY(dest_shape_id == INVALID_SHAPE_ID)) {
1451 RB_OBJ_WRITE(fields_obj, &rb_imemo_fields_ptr(fields_obj)[cache.index], val);
1453 if (shape_id != dest_shape_id) {
1454 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1455 RBASIC_SET_SHAPE_ID(fields_obj, dest_shape_id);
1458 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1467 VALUE fields_obj = rb_obj_fields(obj,
id);
1468 if (UNLIKELY(!fields_obj)) {
1472 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1473 shape_id_t dest_shape_id = rb_setivar_cache_revalidate(shape_id, RBASIC_SHAPE_ID(fields_obj), cache);
1474 if (UNLIKELY(dest_shape_id == INVALID_SHAPE_ID)) {
1478 RB_OBJ_WRITE(fields_obj, &rb_imemo_fields_ptr(fields_obj)[cache.index], val);
1480 if (shape_id != dest_shape_id) {
1481 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1482 RBASIC_SET_SHAPE_ID(fields_obj, dest_shape_id);
1485 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1499 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1500 shape_id_t dest_shape_id = rb_setivar_cache_revalidate(shape_id, shape_id, cache);
1501 if (UNLIKELY(dest_shape_id == INVALID_SHAPE_ID)) {
1505 VALUE fields_obj = ROBJECT_FIELDS_OBJ(obj);
1506 RB_OBJ_WRITE(fields_obj, &rb_imemo_fields_ptr(fields_obj)[cache.index], val);
1507 if (shape_id != dest_shape_id) {
1508 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1509 if (fields_obj != obj) {
1510 RBASIC_SET_SHAPE_ID(fields_obj, dest_shape_id);
1514 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1515 RB_DEBUG_COUNTER_INC(ivar_set_obj_hit);
1521 RB_DEBUG_COUNTER_INC(ivar_set_ic_miss_noobject);
1531update_classvariable_cache(
const rb_iseq_t *iseq,
VALUE klass,
ID id,
const rb_cref_t * cref, ICVARC ic)
1533 VALUE defined_class = 0;
1537 defined_class =
RBASIC(defined_class)->klass;
1540 VALUE rb_cvc_tbl = RCLASS_CVC_TBL(defined_class);
1542 rb_bug(
"the cvc table should be set");
1546 if (!rb_marked_id_table_lookup(rb_cvc_tbl,
id, &ent_data)) {
1547 rb_bug(
"should have cvar cache entry");
1552 ent->global_cvar_state = GET_GLOBAL_CVAR_STATE();
1562vm_getclassvariable(
const rb_iseq_t *iseq,
const rb_control_frame_t *reg_cfp,
ID id, ICVARC ic)
1564 const rb_cref_t *cref;
1565 cref = vm_get_cref(GET_EP());
1569 if (ic->entry && ic->entry->global_cvar_state == GET_GLOBAL_CVAR_STATE() && ic->entry->cref == cref &&
1570 LIKELY(rb_class_owned_p(ic->entry->class_value))) {
1571 RB_DEBUG_COUNTER_INC(cvar_read_inline_hit);
1573 VALUE v = rb_ivar_lookup(ic->entry->class_value,
id,
Qundef);
1579 VALUE klass = vm_get_cvar_base(cref, reg_cfp, 1);
1581 return update_classvariable_cache(iseq, klass,
id, cref, ic);
1585rb_vm_getclassvariable(
const rb_iseq_t *iseq,
const rb_control_frame_t *cfp,
ID id, ICVARC ic)
1587 return vm_getclassvariable(iseq, cfp,
id, ic);
1591vm_setclassvariable(
const rb_iseq_t *iseq,
const rb_control_frame_t *reg_cfp,
ID id,
VALUE val, ICVARC ic)
1593 const rb_cref_t *cref;
1594 cref = vm_get_cref(GET_EP());
1597 if (ic->entry && ic->entry->global_cvar_state == GET_GLOBAL_CVAR_STATE() && ic->entry->cref == cref &&
1598 LIKELY(rb_class_owned_p(ic->entry->class_value))) {
1599 RB_DEBUG_COUNTER_INC(cvar_write_inline_hit);
1601 rb_class_ivar_set(ic->entry->class_value,
id, val);
1605 VALUE klass = vm_get_cvar_base(cref, reg_cfp, 1);
1609 update_classvariable_cache(iseq, klass,
id, cref, ic);
1613rb_vm_setclassvariable(
const rb_iseq_t *iseq,
const rb_control_frame_t *cfp,
ID id,
VALUE val, ICVARC ic)
1615 vm_setclassvariable(iseq, cfp,
id, val, ic);
1618ALWAYS_INLINE(
static VALUE vm_getinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id, IVC ic));
1620vm_getinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id, IVC ic)
1622 return vm_getivar(obj,
id, iseq, ic, NULL, FALSE,
Qnil);
1626vm_setinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id,
VALUE val, IVC ic)
1633 rb_setivar_cache cache = rb_setivar_cache_unpack(vm_ic_atomic_cache_read(ic));
1634 if (UNLIKELY(UNDEF_P(vm_setivar(obj, val, cache)))) {
1640 if (!UNDEF_P(vm_setivar_class(obj, val, cache))) {
1645 if (!UNDEF_P(vm_setivar_default(obj,
id, val, cache))) {
1649 vm_setivar_slowpath_ivar(obj,
id, val, iseq, ic);
1654rb_vm_setinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id,
VALUE val, IVC ic)
1656 vm_setinstancevariable(iseq, obj,
id, val, ic);
1660rb_vm_getinstancevariable(
const rb_iseq_t *iseq,
VALUE obj,
ID id, IVC ic)
1662 return vm_getinstancevariable(iseq, obj,
id, ic);
1666vm_throw_continue(
const rb_execution_context_t *ec,
VALUE err)
1671 ec->tag->state = RUBY_TAG_FATAL;
1674 ec->tag->state = TAG_THROW;
1676 else if (THROW_DATA_P(err)) {
1677 ec->tag->state = THROW_DATA_STATE((
struct vm_throw_data *)err);
1680 ec->tag->state = TAG_RAISE;
1686vm_throw_start(
const rb_execution_context_t *ec, rb_control_frame_t *
const reg_cfp,
enum ruby_tag_type state,
1687 const int flag,
const VALUE throwobj)
1689 const rb_control_frame_t *escape_cfp = NULL;
1690 const rb_control_frame_t *
const eocfp = RUBY_VM_END_CONTROL_FRAME(ec);
1695 else if (state == TAG_BREAK) {
1697 const VALUE *ep = GET_EP();
1698 const rb_iseq_t *base_iseq = GET_ISEQ();
1699 escape_cfp = reg_cfp;
1701 while (ISEQ_BODY(base_iseq)->
type != ISEQ_TYPE_BLOCK) {
1702 if (ISEQ_BODY(CFP_ISEQ(escape_cfp))->
type == ISEQ_TYPE_CLASS) {
1703 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1704 ep = escape_cfp->ep;
1705 base_iseq = CFP_ISEQ(escape_cfp);
1708 ep = VM_ENV_PREV_EP(ep);
1709 base_iseq = ISEQ_BODY(base_iseq)->parent_iseq;
1710 escape_cfp = rb_vm_search_cf_from_ep(ec, escape_cfp, ep);
1711 VM_ASSERT(CFP_ISEQ(escape_cfp) == base_iseq);
1715 if (VM_FRAME_LAMBDA_P(escape_cfp)) {
1721 ep = VM_ENV_PREV_EP(ep);
1723 while (escape_cfp < eocfp) {
1724 if (escape_cfp->ep == ep) {
1725 const rb_iseq_t *
const iseq = CFP_ISEQ(escape_cfp);
1726 const VALUE epc = CFP_PC(escape_cfp) - ISEQ_BODY(iseq)->iseq_encoded;
1731 for (i=0; i < ct->size; i++) {
1733 UNALIGNED_MEMBER_PTR(ct, entries[i]);
1735 if (entry->type == CATCH_TYPE_BREAK &&
1736 entry->iseq == base_iseq &&
1737 entry->start < epc && entry->end >= epc) {
1738 if (entry->cont == epc) {
1747 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1752 rb_vm_localjump_error(
"break from proc-closure", throwobj, TAG_BREAK);
1755 else if (state == TAG_RETRY) {
1756 const VALUE *ep = VM_ENV_PREV_EP(GET_EP());
1758 escape_cfp = rb_vm_search_cf_from_ep(ec, reg_cfp, ep);
1760 else if (state == TAG_RETURN) {
1761 const VALUE *current_ep = GET_EP();
1762 const VALUE *target_ep = NULL, *target_lep, *ep = current_ep;
1763 int in_class_frame = 0;
1765 escape_cfp = reg_cfp;
1768 while (!VM_ENV_LOCAL_P(ep)) {
1769 if (VM_ENV_FLAGS(ep, VM_FRAME_FLAG_LAMBDA) && target_ep == NULL) {
1772 ep = VM_ENV_PREV_EP(ep);
1776 while (escape_cfp < eocfp) {
1777 const VALUE *lep = VM_CF_LEP(escape_cfp);
1783 if (lep == target_lep &&
1784 VM_FRAME_RUBYFRAME_P(escape_cfp) &&
1785 ISEQ_BODY(CFP_ISEQ(escape_cfp))->
type == ISEQ_TYPE_CLASS) {
1790 if (lep == target_lep) {
1791 if (VM_FRAME_LAMBDA_P(escape_cfp)) {
1793 if (in_class_frame) {
1798 const VALUE *tep = current_ep;
1800 while (target_lep != tep) {
1801 if (escape_cfp->ep == tep) {
1803 if (tep == target_ep) {
1807 goto unexpected_return;
1810 tep = VM_ENV_PREV_EP(tep);
1814 else if (VM_FRAME_RUBYFRAME_P(escape_cfp)) {
1815 switch (ISEQ_BODY(CFP_ISEQ(escape_cfp))->
type) {
1817 case ISEQ_TYPE_MAIN:
1819 if (in_class_frame)
goto unexpected_return;
1820 if (target_ep == NULL) {
1824 goto unexpected_return;
1828 case ISEQ_TYPE_EVAL: {
1829 const rb_iseq_t *is = CFP_ISEQ(escape_cfp);
1830 enum rb_iseq_type t = ISEQ_BODY(is)->type;
1831 while (t == ISEQ_TYPE_RESCUE || t == ISEQ_TYPE_ENSURE || t == ISEQ_TYPE_EVAL) {
1832 if (!(is = ISEQ_BODY(is)->parent_iseq))
break;
1833 t = ISEQ_BODY(is)->type;
1835 toplevel = t == ISEQ_TYPE_TOP || t == ISEQ_TYPE_MAIN;
1838 case ISEQ_TYPE_CLASS:
1847 if (escape_cfp->ep == target_lep && ISEQ_BODY(CFP_ISEQ(escape_cfp))->
type == ISEQ_TYPE_METHOD) {
1848 if (target_ep == NULL) {
1852 goto unexpected_return;
1856 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1859 rb_vm_localjump_error(
"unexpected return", throwobj, TAG_RETURN);
1865 rb_bug(
"isns(throw): unsupported throw type");
1868 ec->tag->state = state;
1869 return (
VALUE)THROW_DATA_NEW(throwobj, escape_cfp, state);
1873vm_throw(
const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
1874 rb_num_t throw_state,
VALUE throwobj)
1876 const int state = (int)(throw_state & VM_THROW_STATE_MASK);
1877 const int flag = (int)(throw_state & VM_THROW_NO_ESCAPE_FLAG);
1880 return vm_throw_start(ec, reg_cfp, state, flag, throwobj);
1883 return vm_throw_continue(ec, throwobj);
1889rb_vm_throw(
const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t throw_state,
VALUE throwobj)
1891 return vm_throw(ec, reg_cfp, throw_state, throwobj);
1894NORETURN(
VALUE rb_zjit_throw(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t throw_state,
VALUE throwobj));
1898rb_zjit_throw(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t throw_state,
VALUE throwobj)
1900 VALUE val = vm_throw(ec, reg_cfp, throw_state, throwobj);
1905 enum ruby_tag_type state = ec->tag->state;
1907 EC_JUMP_TAG(ec, state);
1915 int is_splat = flag & 0x01;
1918 const VALUE obj = ary;
1930 if (num + is_splat == 0) {
1933 else if (flag & 0x02) {
1938 for (i = 0; i < num -
len; i++) {
1943 for (j = 0; i < num; i++, j++) {
1965 for (; i < num -
len; i++) {
1969 for (rb_num_t j = 0; i < num; i++, j++) {
1970 *cfp->sp++ = ptr[
len - j - 1];
1974 for (rb_num_t j = 0; j < num; j++) {
1975 *cfp->sp++ = ptr[num - j - 1];
1983static VALUE vm_call_general(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling);
1988vm_ccs_create(
VALUE klass,
VALUE cc_tbl,
ID mid,
const rb_callable_method_entry_t *cme)
1990 int initial_capa = 2;
1992#if VM_CHECK_MODE > 0
1993 ccs->debug_sig = ~(
VALUE)ccs;
1995 ccs->capa = initial_capa;
1998 METHOD_ENTRY_CACHED_SET((rb_callable_method_entry_t *)cme);
2000 rb_managed_id_table_insert(cc_tbl, mid, (
VALUE)ccs);
2008 if (! vm_cc_markable(cc)) {
2012 if (UNLIKELY(ccs->len == ccs->capa)) {
2015 ccs = ruby_xrealloc(ccs, vm_ccs_alloc_size(ccs->capa));
2016#if VM_CHECK_MODE > 0
2017 ccs->debug_sig = ~(
VALUE)ccs;
2020 rb_managed_id_table_insert(cc_tbl, mid, (
VALUE)ccs);
2022 VM_ASSERT(ccs->len < ccs->capa);
2025 const int pos = ccs->len++;
2026 ccs->entries[pos].argc = vm_ci_argc(ci);
2027 ccs->entries[pos].flag = (
unsigned short)vm_ci_flag(ci);
2028 ccs->entries[pos].kw_len = (
unsigned short)(kwarg ? kwarg->keyword_len : 0);
2031 if (RB_DEBUG_COUNTER_SETMAX(ccs_maxlen, ccs->len)) {
2037#if VM_CHECK_MODE > 0
2041 ruby_debug_printf(
"ccs:%p (%d,%d)\n", (
void *)ccs, ccs->len, ccs->capa);
2042 for (
int i=0; i<ccs->len; i++) {
2043 ruby_debug_printf(
"CCS CI ID:flag:%x argc:%u kw_len:%u\n",
2044 ccs->entries[i].flag,
2045 ccs->entries[i].argc,
2046 ccs->entries[i].kw_len);
2047 rp(ccs->entries[i].cc);
2054 VM_ASSERT(vm_ccs_p(ccs));
2055 VM_ASSERT(ccs->len <= ccs->capa);
2057 for (
int i=0; i<ccs->len; i++) {
2060 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
2061 VM_ASSERT(vm_cc_class_check(cc, klass));
2062 VM_ASSERT(vm_cc_check_cme(cc, ccs->cme));
2063 VM_ASSERT(!vm_cc_super_p(cc));
2064 VM_ASSERT(!vm_cc_refinement_p(cc));
2070const rb_callable_method_entry_t *rb_check_overloaded_cme(
const rb_callable_method_entry_t *cme,
const struct rb_callinfo *
const ci);
2075 ASSERT_vm_locking();
2077 if (rb_multi_ractor_p()) {
2078 if (RCLASS_WRITABLE_CC_TBL(klass) != cc_tbl) {
2085 rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj);
2088 if (!ccs || !METHOD_ENTRY_INVALIDATED(ccs->cme)) {
2093 VALUE new_table = rb_vm_cc_table_dup(cc_tbl);
2094 rb_vm_cc_table_delete(new_table, mid);
2095 RB_OBJ_ATOMIC_WRITE(klass, &RCLASS_WRITABLE_CC_TBL(klass), new_table);
2098 rb_vm_cc_table_delete(cc_tbl, mid);
2105 ASSERT_vm_locking();
2107 RB_DEBUG_COUNTER_INC(cc_not_found_in_ccs);
2109 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, mid);
2111 VM_ASSERT(cme == NULL || IMEMO_TYPE_P(cme, imemo_ment));
2115 VM_ASSERT(vm_cc_cme(&rb_vm_empty_cc) == NULL);
2116 return &rb_vm_empty_cc;
2119 if (UNLIKELY(cme->def->uncached && !(vm_ci_flag(ci) & VM_CALL_SUPER))) {
2124 return &rb_vm_uncached_cc;
2127 VALUE cc_tbl = RCLASS_WRITABLE_CC_TBL(klass);
2128 const VALUE original_cc_table = cc_tbl;
2131 cc_tbl = rb_vm_cc_table_create(1);
2133 else if (rb_multi_ractor_p()) {
2134 cc_tbl = rb_vm_cc_table_dup(cc_tbl);
2137 VM_ASSERT(cme == rb_callable_method_entry(klass, mid));
2146 if (UNLIKELY(rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj))) {
2151 ccs = vm_ccs_create(klass, cc_tbl, mid, cme);
2155 cme = rb_check_overloaded_cme(cme, ci);
2157 const struct rb_callcache *cc = vm_cc_new(klass, cme, vm_call_general, cc_type_normal);
2158 vm_ccs_push(cc_tbl, mid, ccs, ci, cc);
2160 VM_ASSERT(vm_cc_cme(cc) != NULL);
2161 VM_ASSERT(cme->called_id == mid);
2162 VM_ASSERT(vm_cc_cme(cc)->called_id == mid);
2164 if (original_cc_table != cc_tbl) {
2165 RB_OBJ_ATOMIC_WRITE(klass, &RCLASS_WRITABLE_CC_TBL(klass), cc_tbl);
2177 cc_tbl = RUBY_ATOMIC_VALUE_LOAD(RCLASS_WRITABLE_CC_TBL(klass));
2185 if (rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj)) {
2187 const int ccs_len = ccs->len;
2189 if (UNLIKELY(METHOD_ENTRY_INVALIDATED(ccs->cme))) {
2191 vm_evict_cc(klass, cc_tbl, mid);
2195 else if (UNDEFINED_METHOD_ENTRY_P(ccs->cme)) {
2197 return &rb_vm_empty_cc;
2200 VM_ASSERT(vm_ccs_verify(ccs, mid, klass));
2209 unsigned int argc = vm_ci_argc(ci);
2210 unsigned int flag = vm_ci_flag(ci);
2211 unsigned int kw_len = kwarg ? kwarg->keyword_len : 0;
2213 for (
int i=0; i<ccs_len; i++) {
2214 unsigned int ccs_ci_argc = ccs->entries[i].argc;
2215 unsigned int ccs_ci_flag = ccs->entries[i].flag;
2216 unsigned int ccs_ci_kw_len = ccs->entries[i].kw_len;
2217 const struct rb_callcache *ccs_cc = ccs->entries[i].cc;
2219 VM_ASSERT(IMEMO_TYPE_P(ccs_cc, imemo_callcache));
2221 if (ccs_ci_argc == argc && ccs_ci_flag == flag && ccs_ci_kw_len == kw_len) {
2222 RB_DEBUG_COUNTER_INC(cc_found_in_ccs);
2224 VM_ASSERT(vm_cc_cme(ccs_cc)->called_id == mid);
2225 VM_ASSERT(ccs_cc->klass == klass);
2226 VM_ASSERT(!METHOD_ENTRY_INVALIDATED(vm_cc_cme(ccs_cc)));
2242 const ID mid = vm_ci_mid(ci);
2244 const struct rb_callcache *cc = vm_lookup_cc(klass, ci, mid);
2250 if (rb_multi_ractor_p()) {
2253 cc = vm_lookup_cc(klass, ci, mid);
2257 cc = vm_populate_cc(klass, ci, mid);
2264#if VM_CHECK_MODE > 0
2268 return cc != &rb_vm_empty_cc && cc != &rb_vm_uncached_cc;
2285 rb_bug(
"attempted to search method '%s' on a garbage collected object",
2286 rb_id2name(vm_ci_mid(ci)));
2291 cc = vm_search_cc(klass, ci);
2294 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
2295 VM_ASSERT(!vm_cc_resolved_p(cc) || cc->klass == klass);
2296 VM_ASSERT(!vm_cc_resolved_p(cc) || callable_method_entry_p(vm_cc_cme(cc)));
2297 VM_ASSERT(!vm_cc_resolved_p(cc) || !METHOD_ENTRY_INVALIDATED(vm_cc_cme(cc)));
2298 VM_ASSERT(!vm_cc_resolved_p(cc) || vm_cc_cme(cc)->called_id == vm_ci_mid(ci));
2303#if VM_CHECK_MODE > 0
2305vm_cd_owned_by_iseq_p(
const struct rb_call_data *cd,
const rb_iseq_t *iseq)
2308 return cd >= body->call_data && cd < body->call_data + body->ci_size;
2315#if USE_DEBUG_COUNTER
2317 const rb_callable_method_entry_t *
const old_cme = old_cc ? old_cc->cme_ : NULL;
2320 const struct rb_callcache *cc = rb_vm_search_method_slowpath(cd->ci, klass);
2321 const rb_callable_method_entry_t *
const new_cme = vm_cc_cme(cc);
2323#if OPT_INLINE_METHOD_CACHE
2326 if (cd_owner && vm_cc_markable(cc)) {
2329 VM_ASSERT(!vm_ci_markable(cd->ci) ||
2330 vm_cd_owned_by_iseq_p(cd, (
const rb_iseq_t *)cd_owner));
2334#if USE_DEBUG_COUNTER
2336 if (!old_cc || old_cc == empty_cc) {
2338 RB_DEBUG_COUNTER_INC(mc_inline_miss_empty);
2340 else if (old_cc == cc) {
2341 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_cc);
2343 else if (old_cme == new_cme) {
2344 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_cme);
2346 else if (old_cme && new_cme && old_cme->def == new_cme->def) {
2347 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_def);
2350 RB_DEBUG_COUNTER_INC(mc_inline_miss_diff);
2355 if (new_cme) VM_ASSERT(new_cme->called_id == vm_ci_mid(cd->ci));
2366#if OPT_INLINE_METHOD_CACHE
2367 if (LIKELY(vm_cc_class_check(cc, klass))) {
2368 if (LIKELY(!METHOD_ENTRY_INVALIDATED(vm_cc_cme(cc)))) {
2369 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
2370 RB_DEBUG_COUNTER_INC(mc_inline_hit);
2371 VM_ASSERT(vm_cc_cme(cc) == NULL ||
2372 (vm_ci_flag(cd->ci) & VM_CALL_SUPER) ||
2373 vm_cc_cme(cc)->called_id == vm_ci_mid(cd->ci));
2377 RB_DEBUG_COUNTER_INC(mc_inline_miss_invalidated);
2380 RB_DEBUG_COUNTER_INC(mc_inline_miss_klass);
2392 if (vm_cc_hit_p(cc, cd, klass)) {
2395 if (UNLIKELY(cc == &rb_vm_uncached_cc)) {
2399 return vm_search_method_slowpath0((
VALUE)CFP_ISEQ(reg_cfp), cd, klass);
2406 VM_ASSERT(klass !=
Qfalse);
2409 const struct rb_callcache *cc = vm_search_method_fastpath(reg_cfp, cd, klass);
2410 return vm_cc_cme(cc);
2414vm_call_uncached(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
2416 RB_DEBUG_COUNTER_INC(ccf_uncached);
2420 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, vm_ci_mid(cd->ci));
2422 if (UNLIKELY(cme == NULL || !cme->def->uncached)) {
2426 vm_search_method_slowpath0((
VALUE)CFP_ISEQ(cfp), (
struct rb_call_data *)cd, klass);
2428 return vm_cc_call(cc)(ec, cfp, calling);
2431 calling->cc = &VM_CC_ON_STACK(klass, vm_call_general, {{ 0 }},
2432 rb_check_overloaded_cme(cme, cd->ci));
2433 return vm_call_general(ec, cfp, calling);
2443 if (!vm_cc_hit_p(cc, cd, klass)) {
2444 if (UNLIKELY(cc == &rb_vm_uncached_cc)) {
2445 return rb_callable_method_entry(klass, vm_ci_mid(cd->ci));
2447 cc = vm_search_method_slowpath0(cd_owner, cd, klass);
2449 return vm_cc_cme(cc);
2452#if __has_attribute(transparent_union)
2465 VALUE (*f10)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2466 VALUE (*f11)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2467 VALUE (*f12)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2468 VALUE (*f13)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2469 VALUE (*f14)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2470 VALUE (*f15)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE);
2473# define make_cfunc_type(f) (cfunc_type){.anyargs = (VALUE (*)(ANYARGS))(f)}
2476# define make_cfunc_type(f) (cfunc_type)(f)
2480cfunc_p(
const rb_callable_method_entry_t *me)
2486 VM_ASSERT(IMEMO_TYPE_P(me, imemo_ment));
2487 VM_ASSERT(callable_method_entry_p(me));
2490 return me->def->type == VM_METHOD_TYPE_CFUNC;
2494cfunc_equal(
const rb_callable_method_entry_t *me, cfunc_type func)
2496 VM_ASSERT(cfunc_p(me));
2498#if __has_attribute(transparent_union)
2499 return me->def->body.cfunc.func == func.anyargs;
2501 return me->def->body.cfunc.func == func;
2506check_cfunc(
const rb_callable_method_entry_t *me, cfunc_type func)
2508 return cfunc_p(me) && cfunc_equal(me, func);
2512check_method_basic_definition(
const rb_callable_method_entry_t *me)
2514 return me && METHOD_ENTRY_BASIC(me);
2520 VM_ASSERT(reg_cfp != NULL);
2522 return check_cfunc(cme, func);
2526rb_zjit_cme_is_cfunc(
const rb_callable_method_entry_t *me,
const cfunc_type func)
2528 return check_cfunc(me, func);
2532rb_vm_method_cfunc_is(
const rb_iseq_t *iseq, CALL_DATA cd,
VALUE recv, cfunc_type func)
2535 return check_cfunc(cme, func);
2538#define check_cfunc(me, func) check_cfunc(me, make_cfunc_type(func))
2539#define vm_method_cfunc_is(reg_cfp, cd, recv, func) vm_method_cfunc_is(reg_cfp, cd, recv, make_cfunc_type(func))
2541#define OP_UNREDEFINED_P(op, t) BASIC_OP_UNREDEFINED_P(BOP_##op, t##_REDEFINED_OP_FLAG)
2542#define EQ_UNREDEFINED_P(t) OP_UNREDEFINED_P(EQ, t)
2574opt_equality_specialized(
VALUE recv,
VALUE obj)
2577 if (OP_UNREDEFINED_P(EQ, ANY)) {
2587 return opt_equality_specialized_miss(recv, obj);
2593 VM_ASSERT(reg_cfp != NULL);
2595 VALUE val = opt_equality_specialized(recv, obj);
2596 if (!UNDEF_P(val))
return val;
2598 if (!vm_method_cfunc_is(reg_cfp, cd, recv, rb_obj_equal)) {
2602 return RBOOL(recv == obj);
2611 const struct rb_callcache *cc = gccct_method_search(GET_EC(), recv, mid, &VM_CI_ON_STACK(mid, 0, 1, NULL));
2613 if (cc && check_cfunc(vm_cc_cme(cc), rb_obj_equal)) {
2614 return RBOOL(recv == obj);
2624 return opt_equality_by_mid(obj1, obj2, idEq);
2630 return opt_equality_by_mid(obj1, obj2, idEqlP);
2633extern VALUE rb_vm_call0(rb_execution_context_t *ec,
VALUE,
ID,
int,
const VALUE*,
const rb_callable_method_entry_t *,
int kw_splat);
2634extern VALUE rb_vm_call_with_refinements(rb_execution_context_t *,
VALUE,
ID,
int,
const VALUE *,
int);
2637check_match(rb_execution_context_t *ec,
VALUE pattern,
VALUE target,
enum vm_check_match_type
type)
2640 case VM_CHECKMATCH_TYPE_WHEN:
2642 case VM_CHECKMATCH_TYPE_RESCUE:
2644 rb_raise(
rb_eTypeError,
"class or module required for rescue clause");
2647 case VM_CHECKMATCH_TYPE_CASE: {
2648 return rb_vm_call_with_refinements(ec, pattern, idEqq, 1, &target,
RB_NO_KEYWORDS);
2651 rb_bug(
"check_match: unreachable");
2657double_cmp_lt(
double a,
double b)
2659 return RBOOL(a < b);
2663double_cmp_le(
double a,
double b)
2665 return RBOOL(a <= b);
2669double_cmp_gt(
double a,
double b)
2671 return RBOOL(a > b);
2675double_cmp_ge(
double a,
double b)
2677 return RBOOL(a >= b);
2681static inline VALUE *
2682vm_base_ptr(
const rb_control_frame_t *cfp)
2684 const rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
2686 if (CFP_ISEQ(cfp) && VM_FRAME_RUBYFRAME_P(cfp)) {
2687 VALUE *bp = prev_cfp->sp + ISEQ_BODY(CFP_ISEQ(cfp))->local_table_size + VM_ENV_DATA_SIZE;
2689 if (ISEQ_BODY(CFP_ISEQ(cfp))->param.flags.forwardable && VM_ENV_LOCAL_P(cfp->ep)) {
2690 int lts = ISEQ_BODY(CFP_ISEQ(cfp))->local_table_size;
2691 int params = ISEQ_BODY(CFP_ISEQ(cfp))->param.size;
2693 CALL_INFO ci = (CALL_INFO)cfp->ep[-(VM_ENV_DATA_SIZE + (lts - params))];
2694 bp += vm_ci_argc(ci);
2697 if (ISEQ_BODY(CFP_ISEQ(cfp))->
type == ISEQ_TYPE_METHOD || VM_FRAME_BMETHOD_P(cfp)) {
2701#if VM_DEBUG_BP_CHECK
2702 if (bp != cfp->bp_check) {
2703 ruby_debug_printf(
"bp_check: %ld, bp: %ld\n",
2704 (
long)(cfp->bp_check - GET_EC()->vm_stack),
2705 (
long)(bp - GET_EC()->vm_stack));
2706 rb_bug(
"vm_base_ptr: unreachable");
2717rb_vm_base_ptr(
const rb_control_frame_t *cfp)
2719 return vm_base_ptr(cfp);
2726static 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,
unsigned int param_size,
unsigned int local_size);
2727ALWAYS_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));
2728static 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,
unsigned int param_size,
unsigned int local_size);
2729static VALUE vm_call_super_method(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling);
2730static VALUE vm_call_method_nome(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling);
2731static VALUE vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling);
2732static inline VALUE vm_call_method(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling);
2734static vm_call_handler vm_call_iseq_setup_func(
const struct rb_callinfo *ci,
const int param_size,
const int local_size);
2737vm_call_iseq_setup_tailcall_0start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
2739 RB_DEBUG_COUNTER_INC(ccf_iseq_setup_tailcall_0start);
2742 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
2743 unsigned int param = ISEQ_BODY(iseq)->param.size;
2744 unsigned int local = ISEQ_BODY(iseq)->local_table_size;
2745 return vm_call_iseq_setup_tailcall(ec, cfp, calling, 0, param, local);
2749vm_call_iseq_setup_normal_0start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
2751 RB_DEBUG_COUNTER_INC(ccf_iseq_setup_0start);
2754 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
2755 int param = ISEQ_BODY(iseq)->param.size;
2756 int local = ISEQ_BODY(iseq)->local_table_size;
2757 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
2761rb_simple_iseq_p(
const rb_iseq_t *iseq)
2763 return ISEQ_BODY(iseq)->param.flags.has_opt == FALSE &&
2764 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2765 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2766 ISEQ_BODY(iseq)->param.flags.has_kw == FALSE &&
2767 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2768 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg == FALSE &&
2769 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2770 ISEQ_BODY(iseq)->param.flags.has_block == FALSE &&
2771 ISEQ_BODY(iseq)->param.flags.accepts_no_block == FALSE;
2775rb_iseq_only_optparam_p(
const rb_iseq_t *iseq)
2777 return ISEQ_BODY(iseq)->param.flags.has_opt == TRUE &&
2778 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2779 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2780 ISEQ_BODY(iseq)->param.flags.has_kw == FALSE &&
2781 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2782 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg == FALSE &&
2783 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2784 ISEQ_BODY(iseq)->param.flags.has_block == FALSE &&
2785 ISEQ_BODY(iseq)->param.flags.accepts_no_block == FALSE;
2789rb_iseq_only_kwparam_p(
const rb_iseq_t *iseq)
2791 return ISEQ_BODY(iseq)->param.flags.has_opt == FALSE &&
2792 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2793 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2794 ISEQ_BODY(iseq)->param.flags.has_kw == TRUE &&
2795 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2796 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2797 ISEQ_BODY(iseq)->param.flags.has_block == FALSE &&
2798 ISEQ_BODY(iseq)->param.flags.accepts_no_block == FALSE;
2801#define ALLOW_HEAP_ARGV (-2)
2802#define ALLOW_HEAP_ARGV_KEEP_KWSPLAT (-3)
2805vm_caller_setup_arg_splat(rb_control_frame_t *cfp,
struct rb_calling_info *calling,
VALUE ary,
int max_args)
2807 vm_check_canary(GET_EC(), cfp->sp);
2813 int argc = calling->argc;
2815 if (UNLIKELY(max_args <= ALLOW_HEAP_ARGV && len + argc > VM_ARGC_STACK_MAX)) {
2819 VALUE *argv = cfp->sp - argc;
2823 cfp->sp -= argc - 1;
2824 cfp->sp[-1] = argv_ary;
2826 calling->heap_argv = argv_ary;
2832 if (max_args >= 0 &&
len + argc > max_args) {
2840 calling->argc +=
len - (max_args - argc + 1);
2841 len = max_args - argc + 1;
2850 calling->heap_argv = 0;
2852 CHECK_VM_STACK_OVERFLOW(cfp,
len);
2854 for (i = 0; i <
len; i++) {
2855 *cfp->sp++ = ptr[i];
2867 const VALUE *
const passed_keywords = vm_ci_kwarg(ci)->keywords;
2868 const int kw_len = vm_ci_kwarg(ci)->keyword_len;
2869 const VALUE h = rb_hash_new_capa(kw_len);
2870 VALUE *sp = cfp->sp;
2873 for (i=0; i<kw_len; i++) {
2874 rb_hash_aset(h, passed_keywords[i], (sp - kw_len)[i]);
2878 cfp->sp -= kw_len - 1;
2879 calling->argc -= kw_len - 1;
2880 calling->kw_splat = 1;
2884vm_caller_setup_keyword_hash(
const struct rb_callinfo *ci,
VALUE keyword_hash)
2887 if (keyword_hash !=
Qnil) {
2889 keyword_hash = rb_hash_dup(rb_to_hash_type(keyword_hash));
2892 else if (!IS_ARGS_KW_SPLAT_MUT(ci) && !
RHASH_EMPTY_P(keyword_hash)) {
2898 keyword_hash = rb_hash_dup(keyword_hash);
2900 return keyword_hash;
2906 const struct rb_callinfo *restrict ci,
int max_args)
2908 if (UNLIKELY(IS_ARGS_SPLAT(ci))) {
2909 if (IS_ARGS_KW_SPLAT(ci)) {
2911 VM_ASSERT(calling->kw_splat == 1);
2915 VALUE ary = cfp->sp[0];
2916 VALUE kwh = vm_caller_setup_keyword_hash(ci, cfp->sp[1]);
2919 if (vm_caller_setup_arg_splat(cfp, calling, ary, max_args))
return;
2923 if (UNLIKELY(calling->heap_argv)) {
2925 ((
struct RHash *)kwh)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
2926 if (max_args != ALLOW_HEAP_ARGV_KEEP_KWSPLAT) {
2927 calling->kw_splat = 0;
2935 VM_ASSERT(calling->kw_splat == 1);
2939 calling->kw_splat = 0;
2944 VM_ASSERT(calling->kw_splat == 0);
2948 VALUE ary = cfp->sp[0];
2950 if (vm_caller_setup_arg_splat(cfp, calling, ary, max_args)) {
2955 VALUE last_hash, argv_ary;
2956 if (UNLIKELY(argv_ary = calling->heap_argv)) {
2957 if (!IS_ARGS_KEYWORD(ci) &&
2960 (((
struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS)) {
2965 calling->kw_splat = 1;
2971 if (!IS_ARGS_KEYWORD(ci) &&
2972 calling->argc > 0 &&
2974 (((
struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS)) {
2981 cfp->sp[-1] = rb_hash_dup(last_hash);
2982 calling->kw_splat = 1;
2988 else if (UNLIKELY(IS_ARGS_KW_SPLAT(ci))) {
2990 VM_ASSERT(calling->kw_splat == 1);
2991 VALUE kwh = vm_caller_setup_keyword_hash(ci, cfp->sp[-1]);
2996 calling->kw_splat = 0;
3002 else if (UNLIKELY(IS_ARGS_KEYWORD(ci))) {
3004 VM_ASSERT(calling->kw_splat == 0);
3010 vm_caller_setup_arg_kw(cfp, calling, ci);
3014#define USE_OPT_HIST 0
3017#define OPT_HIST_MAX 64
3018static int opt_hist[OPT_HIST_MAX+1];
3022opt_hist_show_results_at_exit(
void)
3024 for (
int i=0; i<OPT_HIST_MAX; i++) {
3025 ruby_debug_printf(
"opt_hist\t%d\t%d\n", i, opt_hist[i]);
3031vm_call_iseq_setup_normal_opt_start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3035 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3036 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3037 const int opt = calling->argc - lead_num;
3038 const int opt_num = ISEQ_BODY(iseq)->param.opt_num;
3039 const int opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
3040 const int param = ISEQ_BODY(iseq)->param.size;
3041 const int local = ISEQ_BODY(iseq)->local_table_size;
3042 const int delta = opt_num - opt;
3044 RB_DEBUG_COUNTER_INC(ccf_iseq_opt);
3047 if (opt_pc < OPT_HIST_MAX) {
3051 opt_hist[OPT_HIST_MAX]++;
3055 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), opt_pc, param - delta, local);
3059vm_call_iseq_setup_tailcall_opt_start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3063 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3064 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3065 const int opt = calling->argc - lead_num;
3066 const int opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
3067 unsigned const int param = ISEQ_BODY(iseq)->param.size;
3068 unsigned const int local = ISEQ_BODY(iseq)->local_table_size;
3070 RB_DEBUG_COUNTER_INC(ccf_iseq_opt);
3073 if (opt_pc < OPT_HIST_MAX) {
3077 opt_hist[OPT_HIST_MAX]++;
3081 return vm_call_iseq_setup_tailcall(ec, cfp, calling, opt_pc, param, local);
3085args_setup_kw_parameters(rb_execution_context_t *
const ec,
const rb_iseq_t *
const iseq,
const rb_callable_method_entry_t *cme,
3086 VALUE *
const passed_values,
const int passed_keyword_len,
const VALUE *
const passed_keywords,
3087 VALUE *
const locals);
3090vm_call_iseq_forwardable(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3094 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3095 int param_size = ISEQ_BODY(iseq)->param.size;
3096 int local_size = ISEQ_BODY(iseq)->local_table_size;
3099 VM_ASSERT(ISEQ_BODY(iseq)->param.flags.forwardable);
3101 local_size = local_size + vm_ci_argc(calling->cd->ci);
3102 param_size = param_size + vm_ci_argc(calling->cd->ci);
3104 cfp->sp[0] = (
VALUE)calling->cd->ci;
3106 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param_size, local_size);
3110vm_call_iseq_setup_kwparm_kwarg(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3116 VM_ASSERT(vm_ci_flag(ci) & VM_CALL_KWARG);
3117 RB_DEBUG_COUNTER_INC(ccf_iseq_kw1);
3119 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3120 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3122 const int ci_kw_len = kw_arg->keyword_len;
3123 const VALUE *
const ci_keywords = kw_arg->keywords;
3124 VALUE *argv = cfp->sp - calling->argc;
3125 VALUE *
const klocals = argv + kw_param->bits_start - kw_param->num;
3126 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3128 MEMCPY(ci_kws, argv + lead_num,
VALUE, ci_kw_len);
3129 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), ci_kws, ci_kw_len, ci_keywords, klocals);
3131 int param = ISEQ_BODY(iseq)->param.size;
3132 int local = ISEQ_BODY(iseq)->local_table_size;
3133 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
3137vm_call_iseq_setup_kwparm_nokwarg(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3140 const struct rb_callinfo *MAYBE_UNUSED(ci) = calling->cd->ci;
3143 VM_ASSERT((vm_ci_flag(ci) & VM_CALL_KWARG) == 0);
3144 RB_DEBUG_COUNTER_INC(ccf_iseq_kw2);
3146 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3147 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3148 VALUE *
const argv = cfp->sp - calling->argc;
3149 VALUE *
const klocals = argv + kw_param->bits_start - kw_param->num;
3152 for (i=0; i<kw_param->num; i++) {
3153 klocals[i] = kw_param->default_values[i];
3160 int param = ISEQ_BODY(iseq)->param.size;
3161 int local = ISEQ_BODY(iseq)->local_table_size;
3162 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
3165static VALUE builtin_invoker0(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr);
3168vm_call_single_noarg_leaf_builtin(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3173 vm_call_handler call = (vm_call_handler)(uintptr_t)rbimpl_atomic_ptr_load((
void **)&cc->call_, RBIMPL_ATOMIC_ACQUIRE);
3174 if (UNLIKELY(call != vm_call_single_noarg_leaf_builtin)) {
3175 return call(ec, cfp, calling);
3178 cfp->sp -= (calling->argc + 1);
3179 rb_insn_func_t func_ptr = (rb_insn_func_t)(uintptr_t)bf->func_ptr;
3180 return builtin_invoker0(ec, calling->recv, NULL, func_ptr);
3186warn_unused_block(
const rb_callable_method_entry_t *cme,
const rb_iseq_t *iseq,
void *pc)
3188 rb_vm_t *vm = GET_VM();
3189 set_table *dup_check_table = &vm->unused_block_warning_table;
3199 .v = (
VALUE)cme->def,
3203 if (!strict_unused_block) {
3204 key = (st_data_t)cme->def->original_id;
3206 if (set_table_lookup(dup_check_table, key)) {
3216 key |= (st_data_t)(k1.b[i] ^ k2.b[
SIZEOF_VALUE-1-i]) << (8 * i);
3221 fprintf(stderr,
"pc:%p def:%p\n", pc, (
void *)cme->def);
3222 fprintf(stderr,
"key:%p\n", (
void *)key);
3226 if (set_insert(dup_check_table, key)) {
3230 VALUE m_loc = rb_method_entry_location((
const rb_method_entry_t *)cme);
3231 VALUE name = rb_gen_method_name(cme->defined_class, rb_iseq_base_label(iseq));
3233 if (!
NIL_P(m_loc)) {
3234 rb_warn(
"the block passed to '%"PRIsVALUE
"' defined at %"PRIsVALUE
":%"PRIsVALUE
" may be ignored",
3238 rb_warn(
"the block may be ignored because '%"PRIsVALUE
"' does not use a block", name);
3244vm_callee_setup_arg(rb_execution_context_t *ec,
struct rb_calling_info *calling,
3245 const rb_iseq_t *iseq,
VALUE *argv,
int param_size,
int local_size)
3250 VM_ASSERT((vm_ci_argc(ci), 1));
3251 VM_ASSERT(vm_cc_cme(cc) != NULL);
3253 if (UNLIKELY(!ISEQ_BODY(iseq)->param.flags.use_block &&
3254 calling->block_handler != VM_BLOCK_HANDLER_NONE &&
3255 !(vm_ci_flag(calling->cd->ci) & (VM_CALL_OPT_SEND | VM_CALL_SUPER)))) {
3256 warn_unused_block(vm_cc_cme(cc), iseq, (
void *)CFP_PC(ec->cfp));
3259 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_KW_SPLAT))) {
3260 if (LIKELY(rb_simple_iseq_p(iseq))) {
3261 rb_control_frame_t *cfp = ec->cfp;
3262 int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3263 CALLER_SETUP_ARG(cfp, calling, ci, lead_num);
3265 if (calling->argc != lead_num) {
3266 argument_arity_error(ec, iseq, vm_cc_cme(cc), calling->argc, lead_num, lead_num);
3270 VM_ASSERT(cc == calling->cc);
3272 if (vm_call_iseq_optimizable_p(ci, cc)) {
3273 if ((ISEQ_BODY(iseq)->builtin_attrs & BUILTIN_ATTR_SINGLE_NOARG_LEAF) && ruby_vm_c_events_enabled == 0) {
3274 VM_ASSERT(ISEQ_BODY(iseq)->builtin_attrs & BUILTIN_ATTR_LEAF);
3275 vm_cc_bf_set(cc, (
void *)ISEQ_BODY(iseq)->iseq_encoded[1]);
3276 rbimpl_atomic_ptr_store((
volatile void **)&cc->call_,
3277 (
void *)(uintptr_t)vm_call_single_noarg_leaf_builtin,
3278 RBIMPL_ATOMIC_RELEASE);
3281 CC_SET_FASTPATH(cc, vm_call_iseq_setup_func(ci, param_size, local_size),
true);
3286 else if (rb_iseq_only_optparam_p(iseq)) {
3287 rb_control_frame_t *cfp = ec->cfp;
3289 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3290 const int opt_num = ISEQ_BODY(iseq)->param.opt_num;
3292 CALLER_SETUP_ARG(cfp, calling, ci, lead_num + opt_num);
3293 const int argc = calling->argc;
3294 const int opt = argc - lead_num;
3296 if (opt < 0 || opt > opt_num) {
3297 argument_arity_error(ec, iseq, vm_cc_cme(cc), argc, lead_num, lead_num + opt_num);
3300 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {
3301 CC_SET_FASTPATH(cc, vm_call_iseq_setup_normal_opt_start,
3302 !IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&
3303 vm_call_cacheable(ci, cc));
3306 CC_SET_FASTPATH(cc, vm_call_iseq_setup_tailcall_opt_start,
3307 !IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&
3308 vm_call_cacheable(ci, cc));
3312 VM_ASSERT((
int)ISEQ_BODY(iseq)->param.size == lead_num + opt_num);
3313 for (
int i=argc; i<lead_num + opt_num; i++) {
3316 return (
int)ISEQ_BODY(iseq)->param.opt_table[opt];
3318 else if (rb_iseq_only_kwparam_p(iseq) && !IS_ARGS_SPLAT(ci)) {
3319 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3320 const int argc = calling->argc;
3321 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3323 if (vm_ci_flag(ci) & VM_CALL_KWARG) {
3326 if (argc - kw_arg->keyword_len == lead_num) {
3327 const int ci_kw_len = kw_arg->keyword_len;
3328 const VALUE *
const ci_keywords = kw_arg->keywords;
3330 MEMCPY(ci_kws, argv + lead_num,
VALUE, ci_kw_len);
3332 VALUE *
const klocals = argv + kw_param->bits_start - kw_param->num;
3333 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), ci_kws, ci_kw_len, ci_keywords, klocals);
3335 CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_kwarg,
3336 vm_call_cacheable(ci, cc));
3341 else if (argc == lead_num) {
3343 VALUE *
const klocals = argv + kw_param->bits_start - kw_param->num;
3344 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), NULL, 0, NULL, klocals);
3346 if (klocals[kw_param->num] ==
INT2FIX(0)) {
3348 CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_nokwarg,
3349 vm_call_cacheable(ci, cc));
3375 if (ISEQ_BODY(iseq)->param.flags.forwardable) {
3376 bool can_fastpath =
true;
3378 if ((vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
3380 if (vm_ci_argc(ci) != vm_ci_argc(forward_cd->caller_ci)) {
3381 ci = vm_ci_new_runtime(
3388 ci = forward_cd->caller_ci;
3390 can_fastpath =
false;
3394 if (!vm_ci_markable(ci)) {
3395 ci = vm_ci_new_runtime(
3400 can_fastpath =
false;
3402 argv[param_size - 1] = (
VALUE)ci;
3403 CC_SET_FASTPATH(cc, vm_call_iseq_forwardable, can_fastpath);
3407 return setup_parameters_complex(ec, iseq, calling, ci, argv, arg_setup_method);
3434 const VALUE * lep = VM_CF_LEP(cfp);
3436 const rb_iseq_t *iseq;
3440 if (VM_ENV_FLAGS(lep, VM_ENV_FLAG_ESCAPED)) {
3445 iseq = CFP_ISEQ(rb_vm_search_cf_from_ep(ec, cfp, lep));
3449 int local_size = ISEQ_BODY(iseq)->local_table_size + argc;
3451 const VALUE * from = lep - (local_size + VM_ENV_DATA_SIZE - 1);
3452 VALUE * to = cfp->sp - 1;
3456 CHECK_VM_STACK_OVERFLOW0(cfp, to,
RARRAY_LEN(splat));
3461 CHECK_VM_STACK_OVERFLOW0(cfp, to, argc);
3463 cfp->sp = to + argc;
3480vm_call_iseq_setup(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
3482 RB_DEBUG_COUNTER_INC(ccf_iseq_setup);
3485 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3486 unsigned int param_size = ISEQ_BODY(iseq)->param.size;
3487 unsigned int local_size = ISEQ_BODY(iseq)->local_table_size;
3489 RUBY_ASSERT(!ISEQ_BODY(iseq)->param.flags.forwardable);
3491 const int opt_pc = vm_callee_setup_arg(ec, calling, iseq, cfp->sp - calling->argc, param_size, local_size);
3492 return vm_call_iseq_setup_2(ec, cfp, calling, opt_pc, param_size, local_size);
3496vm_call_iseq_fwd_setup(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
3498 RB_DEBUG_COUNTER_INC(ccf_iseq_setup);
3501 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3502 unsigned int param_size = ISEQ_BODY(iseq)->param.size;
3503 unsigned int local_size = ISEQ_BODY(iseq)->local_table_size;
3505 RUBY_ASSERT(ISEQ_BODY(iseq)->param.flags.forwardable);
3508 local_size = local_size + vm_ci_argc(calling->cd->ci);
3509 param_size = param_size + vm_ci_argc(calling->cd->ci);
3511 const int opt_pc = vm_callee_setup_arg(ec, calling, iseq, cfp->sp - calling->argc, param_size, local_size);
3512 return vm_call_iseq_setup_2(ec, cfp, calling, opt_pc, param_size, local_size);
3516vm_call_iseq_setup_2(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
3517 int opt_pc,
unsigned int param_size,
unsigned int local_size)
3522 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {
3523 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), opt_pc, param_size, local_size);
3526 return vm_call_iseq_setup_tailcall(ec, cfp, calling, opt_pc, param_size, local_size);
3531vm_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,
3532 int opt_pc,
int param_size,
int local_size)
3534 const rb_iseq_t *iseq = def_iseq_ptr(me->def);
3535 VALUE *argv = cfp->sp - calling->argc;
3536 VALUE *sp = argv + param_size;
3537 cfp->sp = argv - 1 ;
3539 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL, calling->recv,
3540 calling->block_handler, (
VALUE)me,
3541 ISEQ_BODY(iseq)->iseq_encoded + opt_pc, sp,
3542 local_size - param_size,
3543 ISEQ_BODY(iseq)->stack_max);
3548vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
3549 int opt_pc,
unsigned int param_size,
unsigned int local_size)
3552 VALUE *argv = cfp->sp - calling->argc;
3553 const rb_callable_method_entry_t *me = vm_cc_cme(cc);
3554 const rb_iseq_t *iseq = def_iseq_ptr(me->def);
3555 VALUE *src_argv = argv;
3556 VALUE *sp_orig, *sp;
3557 VALUE finish_flag = VM_FRAME_FINISHED_P(cfp) ? VM_FRAME_FLAG_FINISH : 0;
3559 if (VM_BH_FROM_CFP_P(calling->block_handler, cfp)) {
3560 struct rb_captured_block *dst_captured = VM_CFP_TO_CAPTURED_BLOCK(RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
3561 const struct rb_captured_block *src_captured = VM_BH_TO_CAPT_BLOCK(calling->block_handler);
3562 dst_captured->code.val = src_captured->code.val;
3563 if (VM_BH_ISEQ_BLOCK_P(calling->block_handler)) {
3564 calling->block_handler = VM_BH_FROM_ISEQ_BLOCK(dst_captured);
3567 calling->block_handler = VM_BH_FROM_IFUNC_BLOCK(dst_captured);
3571 vm_pop_frame(ec, cfp, cfp->ep);
3574 sp_orig = sp = cfp->sp;
3577 sp[0] = calling->recv;
3581 for (
unsigned int i = 0; i < param_size; i++) {
3582 *sp++ = src_argv[i];
3585 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL | finish_flag,
3586 calling->recv, calling->block_handler, (
VALUE)me,
3587 ISEQ_BODY(iseq)->iseq_encoded + opt_pc, sp,
3588 local_size - param_size,
3589 ISEQ_BODY(iseq)->stack_max);
3597ractor_unsafe_check(
void)
3599 if (!rb_ractor_main_p()) {
3600 rb_raise(rb_eRactorUnsafeError,
"ractor unsafe method called from not main ractor");
3607 ractor_unsafe_check();
3615 ractor_unsafe_check();
3617 return (*f)(argc, argv, recv);
3623 ractor_unsafe_check();
3631 ractor_unsafe_check();
3633 return (*f)(recv, argv[0]);
3639 ractor_unsafe_check();
3641 return (*f)(recv, argv[0], argv[1]);
3647 ractor_unsafe_check();
3649 return (*f)(recv, argv[0], argv[1], argv[2]);
3655 ractor_unsafe_check();
3657 return (*f)(recv, argv[0], argv[1], argv[2], argv[3]);
3663 ractor_unsafe_check();
3664 VALUE(*f)(
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]);
3671 ractor_unsafe_check();
3672 VALUE(*f)(
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]);
3679 ractor_unsafe_check();
3680 VALUE(*f)(
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]);
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))func;
3689 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
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))func;
3697 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
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))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]);
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))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]);
3719 ractor_unsafe_check();
3720 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;
3721 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]);
3727 ractor_unsafe_check();
3728 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;
3729 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]);
3735 ractor_unsafe_check();
3736 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;
3737 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]);
3743 ractor_unsafe_check();
3744 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;
3745 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]);
3759 return (*f)(argc, argv, recv);
3773 return (*f)(recv, argv[0]);
3780 return (*f)(recv, argv[0], argv[1]);
3787 return (*f)(recv, argv[0], argv[1], argv[2]);
3794 return (*f)(recv, argv[0], argv[1], argv[2], argv[3]);
3800 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3801 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4]);
3807 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3808 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
3814 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3815 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
3821 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3822 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
3828 VALUE(*f)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE) = (
VALUE(*)(
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE,
VALUE))func;
3829 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
3835 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;
3836 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]);
3842 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;
3843 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]);
3849 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;
3850 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]);
3856 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;
3857 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]);
3863 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;
3864 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]);
3870 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;
3871 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]);
3875vm_cfp_consistent_p(rb_execution_context_t *ec,
const rb_control_frame_t *reg_cfp)
3877 const int ov_flags = RAISED_STACKOVERFLOW;
3878 if (LIKELY(reg_cfp == ec->cfp + 1))
return TRUE;
3879 if (rb_ec_raised_p(ec, ov_flags)) {
3880 rb_ec_raised_reset(ec, ov_flags);
3886#define CHECK_CFP_CONSISTENCY(func) \
3887 (LIKELY(vm_cfp_consistent_p(ec, reg_cfp)) ? (void)0 : \
3888 rb_bug(func ": cfp consistency error (%p, %p)", (void *)reg_cfp, (void *)(ec->cfp+1)))
3891const rb_method_cfunc_t *
3892vm_method_cfunc_entry(
const rb_callable_method_entry_t *me)
3894#if VM_DEBUG_VERIFY_METHOD_CACHE
3895 switch (me->def->type) {
3896 case VM_METHOD_TYPE_CFUNC:
3897 case VM_METHOD_TYPE_NOTIMPLEMENTED:
3899# define METHOD_BUG(t) case VM_METHOD_TYPE_##t: rb_bug("wrong method type: " #t)
3901 METHOD_BUG(ATTRSET);
3903 METHOD_BUG(BMETHOD);
3906 METHOD_BUG(OPTIMIZED);
3907 METHOD_BUG(MISSING);
3908 METHOD_BUG(REFINED);
3912 rb_bug(
"wrong method type: %d", me->def->type);
3915 return UNALIGNED_MEMBER_PTR(me->def, body.cfunc);
3919vm_call_cfunc_with_frame_(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling,
3922 RB_DEBUG_COUNTER_INC(ccf_cfunc_with_frame);
3926 const rb_callable_method_entry_t *me = vm_cc_cme(cc);
3927 const rb_method_cfunc_t *cfunc = vm_method_cfunc_entry(me);
3929 VALUE recv = calling->recv;
3930 VALUE block_handler = calling->block_handler;
3931 VALUE frame_type = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
3933 if (UNLIKELY(calling->kw_splat)) {
3934 frame_type |= VM_FRAME_FLAG_CFRAME_KW;
3937 VM_ASSERT(reg_cfp == ec->cfp);
3939 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, me->owner, me->def->original_id);
3942 vm_push_frame(ec, NULL, frame_type, recv,
3943 block_handler, (
VALUE)me,
3944 0, ec->cfp->sp, 0, 0);
3946 int len = cfunc->argc;
3949 reg_cfp->sp = stack_bottom;
3950 val = (*cfunc->invoker)(recv, argc, argv, cfunc->func);
3952 CHECK_CFP_CONSISTENCY(
"vm_call_cfunc");
3954 rb_vm_pop_frame(ec);
3956 VM_ASSERT(ec->cfp->sp == stack_bottom);
3958 EXEC_EVENT_HOOK(ec,
RUBY_EVENT_C_RETURN, recv, me->def->original_id, vm_ci_mid(ci), me->owner, val);
3959 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
3967rb_vm_push_cfunc_frame(
const rb_callable_method_entry_t *cme,
int recv_idx)
3969 VM_ASSERT(cme->def->type == VM_METHOD_TYPE_CFUNC);
3970 rb_execution_context_t *ec = GET_EC();
3971 VALUE *sp = ec->cfp->sp;
3972 VALUE recv = *(sp - recv_idx - 1);
3973 VALUE frame_type = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
3974 VALUE block_handler = VM_BLOCK_HANDLER_NONE;
3975#if VM_CHECK_MODE > 0
3977 *(GET_EC()->cfp->sp) =
Qfalse;
3979 vm_push_frame(ec, NULL, frame_type, recv, block_handler, (
VALUE)cme, 0, ec->cfp->sp, 0, 0);
3984rb_splat_or_kwargs_p(
const struct rb_callinfo *restrict ci)
3986 return IS_ARGS_SPLAT(ci) || IS_ARGS_KW_OR_KW_SPLAT(ci);
3990vm_call_get_kwarg(rb_control_frame_t *reg_cfp, CALL_DATA cd,
ID kw)
3994 if (vm_ci_flag(cd->ci) & VM_CALL_KW_SPLAT) {
3995 VALUE keywords = TOPN(0);
3997 TOPN(0) = keywords = rb_to_hash_type(keywords);
3999 return rb_hash_lookup2(keywords, sym,
Qundef);
4004 for (
int index = 0; index < kwarg->keyword_len; index++) {
4005 if (kwarg->keywords[index] == sym) {
4006 return TOPN(kwarg->keyword_len - index - 1);
4015vm_call_cfunc_with_frame(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4017 int argc = calling->argc;
4018 VALUE *stack_bottom = reg_cfp->sp - argc - 1;
4019 VALUE *argv = &stack_bottom[1];
4021 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, argv, stack_bottom);
4025vm_call_cfunc_other(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4028 RB_DEBUG_COUNTER_INC(ccf_cfunc_other);
4030 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV_KEEP_KWSPLAT);
4032 if (UNLIKELY(argv_ary = calling->heap_argv)) {
4033 VM_ASSERT(!IS_ARGS_KEYWORD(ci));
4036 VALUE *stack_bottom = reg_cfp->sp - 2;
4038 VM_ASSERT(calling->argc == 1);
4042 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, argv, stack_bottom);
4045 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));
4047 return vm_call_cfunc_with_frame(ec, reg_cfp, calling);
4052vm_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)
4054 VALUE argv_ary = reg_cfp->sp[-1 - stack_offset];
4057 if (UNLIKELY(argc > VM_ARGC_STACK_MAX)) {
4058 return vm_call_cfunc_other(ec, reg_cfp, calling);
4062 calling->kw_splat = 0;
4064 VALUE *stack_bottom = reg_cfp->sp - 2 - stack_offset;
4065 VALUE *sp = stack_bottom;
4066 CHECK_VM_STACK_OVERFLOW(reg_cfp, argc);
4067 for(i = 0; i < argc; i++) {
4072 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, stack_bottom+1, stack_bottom);
4076vm_call_cfunc_only_splat(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4078 RB_DEBUG_COUNTER_INC(ccf_cfunc_only_splat);
4079 VALUE argv_ary = reg_cfp->sp[-1];
4083 int argc_offset = 0;
4085 if (UNLIKELY(argc > 0 &&
4087 (((
struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS))) {
4089 return vm_call_cfunc_other(ec, reg_cfp, calling);
4093 return vm_call_cfunc_array_argv(ec, reg_cfp, calling, 0, argc_offset);
4097vm_call_cfunc_only_splat_kw(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4099 RB_DEBUG_COUNTER_INC(ccf_cfunc_only_splat_kw);
4100 VALUE keyword_hash = reg_cfp->sp[-1];
4103 return vm_call_cfunc_array_argv(ec, reg_cfp, calling, 1, 0);
4106 return vm_call_cfunc_other(ec, reg_cfp, calling);
4110vm_call_cfunc(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4113 RB_DEBUG_COUNTER_INC(ccf_cfunc);
4115 if (IS_ARGS_SPLAT(ci) && !(vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
4116 if (!IS_ARGS_KW_SPLAT(ci) && vm_ci_argc(ci) == 1) {
4118 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_only_splat, TRUE);
4119 return vm_call_cfunc_only_splat(ec, reg_cfp, calling);
4121 if (IS_ARGS_KW_SPLAT(ci) && vm_ci_argc(ci) == 2) {
4123 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_only_splat_kw, TRUE);
4124 return vm_call_cfunc_only_splat_kw(ec, reg_cfp, calling);
4128 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_other, TRUE);
4129 return vm_call_cfunc_other(ec, reg_cfp, calling);
4133vm_call_ivar(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4136 RB_DEBUG_COUNTER_INC(ccf_ivar);
4138 VALUE ivar = vm_getivar(calling->recv, vm_cc_cme(cc)->def->body.attr.id, NULL, NULL, cc, TRUE,
Qnil);
4143vm_call_attrset_direct(rb_execution_context_t *ec, rb_control_frame_t *cfp,
const struct rb_callcache *cc,
VALUE obj)
4145 RB_DEBUG_COUNTER_INC(ccf_attrset);
4146 VALUE val = *(cfp->sp - 1);
4148 rb_setivar_cache cache = rb_setivar_cache_unpack(vm_cc_atomic_cache_read(cc));
4149 ID id = vm_cc_cme(cc)->def->body.attr.id;
4150 rb_check_frozen(obj);
4151 VALUE res = vm_setivar(obj, val, cache);
4159 res = vm_setivar_class(obj, val, cache);
4160 if (!UNDEF_P(res)) {
4167 res = vm_setivar_default(obj,
id, val, cache);
4168 if (!UNDEF_P(res)) {
4173 res = vm_setivar_slowpath_attr(obj,
id, val, cc);
4179vm_call_attrset(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4181 return vm_call_attrset_direct(ec, cfp, calling->cc, calling->recv);
4185vm_call_bmethod_body(rb_execution_context_t *ec,
struct rb_calling_info *calling,
const VALUE *argv)
4190 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4191 VALUE procv = cme->def->body.bmethod.proc;
4194 cme->def->body.bmethod.defined_ractor_id != rb_ec_ractor_id(ec)) {
4195 rb_raise(
rb_eRuntimeError,
"defined with an un-shareable Proc in a different Ractor");
4199 GetProcPtr(procv, proc);
4200 val = vm_invoke_bmethod(ec, proc, calling->recv, CALLING_ARGC(calling), argv, calling->kw_splat, calling->block_handler, vm_cc_cme(cc));
4205static 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);
4208vm_call_iseq_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4210 RB_DEBUG_COUNTER_INC(ccf_iseq_bmethod);
4213 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4214 VALUE procv = cme->def->body.bmethod.proc;
4217 cme->def->body.bmethod.defined_ractor_id != rb_ec_ractor_id(ec)) {
4218 rb_raise(
rb_eRuntimeError,
"defined with an un-shareable Proc in a different Ractor");
4222 GetProcPtr(procv, proc);
4223 const struct rb_block *block = &proc->block;
4225 while (vm_block_type(block) == block_type_proc) {
4226 block = vm_proc_block(block->as.proc);
4228 VM_ASSERT(vm_block_type(block) == block_type_iseq);
4231 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
4232 VALUE *
const argv = cfp->sp - calling->argc;
4233 const int arg_size = ISEQ_BODY(iseq)->param.size;
4236 if (vm_ci_flag(calling->cd->ci) & VM_CALL_ARGS_SIMPLE) {
4237 opt_pc = vm_callee_setup_block_arg(ec, calling, calling->cd->ci, iseq, argv, arg_setup_method);
4240 opt_pc = setup_parameters_complex(ec, iseq, calling, calling->cd->ci, argv, arg_setup_method);
4245 vm_push_frame(ec, iseq,
4246 VM_FRAME_MAGIC_BLOCK | VM_FRAME_FLAG_BMETHOD | VM_FRAME_FLAG_LAMBDA,
4248 VM_GUARDED_PREV_EP(captured->ep),
4250 ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
4252 ISEQ_BODY(iseq)->local_table_size - arg_size,
4253 ISEQ_BODY(iseq)->stack_max);
4259vm_call_noniseq_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4261 RB_DEBUG_COUNTER_INC(ccf_noniseq_bmethod);
4265 CALLER_SETUP_ARG(cfp, calling, calling->cd->ci, ALLOW_HEAP_ARGV);
4266 if (UNLIKELY(calling->heap_argv)) {
4271 argc = calling->argc;
4274 cfp->sp += - argc - 1;
4277 return vm_call_bmethod_body(ec, calling, argv);
4281vm_call_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4283 RB_DEBUG_COUNTER_INC(ccf_bmethod);
4286 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4287 VALUE procv = cme->def->body.bmethod.proc;
4289 GetProcPtr(procv, proc);
4290 const struct rb_block *block = &proc->block;
4292 while (vm_block_type(block) == block_type_proc) {
4293 block = vm_proc_block(block->as.proc);
4295 if (vm_block_type(block) == block_type_iseq) {
4296 CC_SET_FASTPATH(cc, vm_call_iseq_bmethod, TRUE);
4297 return vm_call_iseq_bmethod(ec, cfp, calling);
4300 CC_SET_FASTPATH(cc, vm_call_noniseq_bmethod, TRUE);
4301 return vm_call_noniseq_bmethod(ec, cfp, calling);
4305rb_find_defined_class_by_owner(
VALUE current_class,
VALUE target_owner)
4307 VALUE klass = current_class;
4315 while (
RTEST(klass)) {
4317 if (owner == target_owner) {
4323 return current_class;
4326static const rb_callable_method_entry_t *
4327aliased_callable_method_entry(
const rb_callable_method_entry_t *me)
4329 const rb_method_entry_t *orig_me =
4330 rb_method_alias_original_me(rb_method_entry_def_acquire((
const rb_method_entry_t *)me));
4331 const rb_callable_method_entry_t *cme = NULL;
4333 if (orig_me->defined_class == 0) {
4339 orig_me = me->def->body.alias.original_me;
4341 if (orig_me->defined_class == 0) {
4343 VALUE defined_class = rb_find_defined_class_by_owner(me->defined_class, orig_me->owner);
4344 VM_ASSERT_TYPE(orig_me->owner,
T_MODULE);
4345 cme = rb_method_entry_complement_defined_class(orig_me, me->called_id, defined_class);
4347 if (me->def->reference_count == 1) {
4348 rbimpl_atomic_ptr_store((
volatile void **)&me->def->body.alias.original_me,
4349 (
void *)cme, RBIMPL_ATOMIC_RELEASE);
4353 rb_method_definition_t *def =
4354 rb_method_definition_create(VM_METHOD_TYPE_ALIAS, me->def->original_id);
4355 def->body.alias.original_me = (rb_method_entry_t *)cme;
4356 def->original_module = cme->def->original_module;
4357 rb_method_definition_set((rb_method_entry_t *)me, def, NULL);
4363 cme = (
const rb_callable_method_entry_t *)orig_me;
4368 cme = (
const rb_callable_method_entry_t *)orig_me;
4371 VM_ASSERT(callable_method_entry_p(cme));
4375const rb_callable_method_entry_t *
4376rb_aliased_callable_method_entry(
const rb_callable_method_entry_t *me)
4378 return aliased_callable_method_entry(me);
4382vm_call_alias(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4384 calling->cc = &VM_CC_ON_STACK(
Qundef,
4387 aliased_callable_method_entry(vm_cc_cme(calling->cc)));
4389 return vm_call_method_each_type(ec, cfp, calling);
4392static enum method_missing_reason
4395 enum method_missing_reason stat = MISSING_NOENTRY;
4396 if (vm_ci_flag(ci) & VM_CALL_VCALL && !(vm_ci_flag(ci) & VM_CALL_FORWARDING)) stat |= MISSING_VCALL;
4397 if (vm_ci_flag(ci) & VM_CALL_FCALL) stat |= MISSING_FCALL;
4398 if (vm_ci_flag(ci) & VM_CALL_SUPER) stat |= MISSING_SUPER;
4402static VALUE vm_call_method_missing(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling);
4405vm_call_symbol(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4408 ASSUME(calling->argc >= 0);
4410 enum method_missing_reason missing_reason = MISSING_NOENTRY;
4411 int argc = calling->argc;
4412 VALUE recv = calling->recv;
4415 flags |= VM_CALL_OPT_SEND;
4417 if (UNLIKELY(! mid)) {
4418 mid = idMethodMissing;
4419 missing_reason = ci_missing_reason(ci);
4420 ec->method_missing_reason = missing_reason;
4423 if (UNLIKELY(argv_ary = calling->heap_argv)) {
4425 rb_ary_unshift(argv_ary, symbol);
4428 int priv = vm_ci_flag(ci) & (VM_CALL_FCALL | VM_CALL_VCALL);
4429 VALUE exc = rb_make_no_method_exception(
4451 CHECK_VM_STACK_OVERFLOW(reg_cfp, 1);
4454 argc = ++calling->argc;
4459 int priv = vm_ci_flag(ci) & (VM_CALL_FCALL | VM_CALL_VCALL);
4460 const VALUE *argv = STACK_ADDR_FROM_TOP(argc);
4461 VALUE exc = rb_make_no_method_exception(
4474 .ci = &VM_CI_ON_STACK(mid, flags, argc, vm_ci_kwarg(ci)),
4480 if (!(vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
4481 calling->cd = &new_fcd.cd;
4485 VM_ASSERT((vm_ci_argc(caller_ci), 1));
4486 new_fcd.caller_ci = caller_ci;
4489 calling->cc = &VM_CC_ON_STACK(klass,
4491 { .method_missing_reason = missing_reason },
4492 rb_callable_method_entry_with_refinements(klass, mid, NULL));
4494 if (flags & VM_CALL_FCALL) {
4495 return vm_call_method(ec, reg_cfp, calling);
4499 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
4501 if (vm_cc_cme(cc) != NULL) {
4502 switch (METHOD_ENTRY_VISI(vm_cc_cme(cc))) {
4503 case METHOD_VISI_PUBLIC:
4504 return vm_call_method_each_type(ec, reg_cfp, calling);
4505 case METHOD_VISI_PRIVATE:
4506 vm_cc_method_missing_reason_set(cc, MISSING_PRIVATE);
4508 case METHOD_VISI_PROTECTED:
4509 vm_cc_method_missing_reason_set(cc, MISSING_PROTECTED);
4512 VM_UNREACHABLE(vm_call_method);
4514 return vm_call_method_missing(ec, reg_cfp, calling);
4517 return vm_call_method_nome(ec, reg_cfp, calling);
4521vm_call_opt_send0(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling,
int flags)
4527 i = calling->argc - 1;
4529 if (calling->argc == 0) {
4530 rb_raise(rb_eArgError,
"no method name given");
4554 return vm_call_symbol(ec, reg_cfp, calling, ci, sym, flags);
4558vm_call_opt_send_complex(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4560 RB_DEBUG_COUNTER_INC(ccf_opt_send_complex);
4562 int flags = VM_CALL_FCALL;
4566 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV);
4567 if (UNLIKELY(argv_ary = calling->heap_argv)) {
4569 flags |= VM_CALL_ARGS_SPLAT;
4570 if (calling->kw_splat) {
4571 VALUE last_hash = rb_ary_last(0, NULL, argv_ary);
4572 ((
struct RHash *)last_hash)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
4573 calling->kw_splat = 0;
4575 return vm_call_symbol(ec, reg_cfp, calling, ci, sym, flags);
4578 if (calling->kw_splat) flags |= VM_CALL_KW_SPLAT;
4579 return vm_call_opt_send0(ec, reg_cfp, calling, flags);
4583vm_call_opt_send_simple(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4585 RB_DEBUG_COUNTER_INC(ccf_opt_send_simple);
4586 return vm_call_opt_send0(ec, reg_cfp, calling, vm_ci_flag(calling->cd->ci) | VM_CALL_FCALL);
4590vm_call_opt_send(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4592 RB_DEBUG_COUNTER_INC(ccf_opt_send);
4595 int flags = vm_ci_flag(ci);
4597 if (UNLIKELY((flags & VM_CALL_FORWARDING) || (!(flags & VM_CALL_ARGS_SIMPLE) &&
4598 ((calling->argc == 1 && (flags & (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT))) ||
4599 (calling->argc == 2 && (flags & VM_CALL_ARGS_SPLAT) && (flags & VM_CALL_KW_SPLAT)) ||
4600 ((flags & VM_CALL_KWARG) && (vm_ci_kwarg(ci)->keyword_len == calling->argc)))))) {
4601 CC_SET_FASTPATH(calling->cc, vm_call_opt_send_complex, TRUE);
4602 return vm_call_opt_send_complex(ec, reg_cfp, calling);
4605 CC_SET_FASTPATH(calling->cc, vm_call_opt_send_simple, TRUE);
4606 return vm_call_opt_send_simple(ec, reg_cfp, calling);
4610vm_call_method_missing_body(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling,
4611 const struct rb_callinfo *orig_ci,
enum method_missing_reason reason)
4613 RB_DEBUG_COUNTER_INC(ccf_method_missing);
4615 VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);
4616 unsigned int argc, flag;
4618 flag = VM_CALL_FCALL | VM_CALL_OPT_SEND | vm_ci_flag(orig_ci);
4619 argc = ++calling->argc;
4622 CHECK_VM_STACK_OVERFLOW(reg_cfp, 1);
4623 vm_check_canary(ec, reg_cfp->sp);
4627 argv[0] =
ID2SYM(vm_ci_mid(orig_ci));
4630 ec->method_missing_reason = reason;
4634 .ci = &VM_CI_ON_STACK(idMethodMissing, flag, argc, vm_ci_kwarg(orig_ci)),
4640 if (!(flag & VM_CALL_FORWARDING)) {
4641 calling->cd = &new_fcd.cd;
4645 VM_ASSERT((vm_ci_argc(caller_ci), 1));
4646 new_fcd.caller_ci = caller_ci;
4650 calling->cc = &VM_CC_ON_STACK(
Qundef, vm_call_general, {{ 0 }},
4651 rb_callable_method_entry_without_refinements(
CLASS_OF(calling->recv), idMethodMissing, NULL));
4652 return vm_call_method(ec, reg_cfp, calling);
4656vm_call_method_missing(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4658 return vm_call_method_missing_body(ec, reg_cfp, calling, calling->cd->ci, vm_cc_cmethod_missing_reason(calling->cc));
4661static const rb_callable_method_entry_t *refined_method_callable_without_refinement(
const rb_callable_method_entry_t *me);
4663vm_call_zsuper(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
VALUE klass)
4667 const rb_callable_method_entry_t *cme = klass ? rb_callable_method_entry(klass, vm_ci_mid(calling->cd->ci)) : NULL;
4669 return vm_call_method_nome(ec, cfp, calling);
4671 if (cme->def->type == VM_METHOD_TYPE_REFINED &&
4672 cme->def->body.refined.orig_me) {
4673 cme = refined_method_callable_without_refinement(cme);
4676 calling->cc = &VM_CC_ON_STACK(
Qundef, vm_call_general, {{ 0 }}, cme);
4678 return vm_call_method_each_type(ec, cfp, calling);
4682find_refinement(
VALUE refinements,
VALUE klass)
4684 if (
NIL_P(refinements)) {
4687 return rb_hash_lookup(refinements, klass);
4690PUREFUNC(
static rb_control_frame_t * current_method_entry(
const rb_execution_context_t *ec, rb_control_frame_t *cfp));
4691static rb_control_frame_t *
4692current_method_entry(
const rb_execution_context_t *ec, rb_control_frame_t *cfp)
4694 rb_control_frame_t *top_cfp = cfp;
4696 if (CFP_ISEQ(cfp) && !VM_FRAME_BMETHOD_P(cfp) && ISEQ_BODY(CFP_ISEQ(cfp))->
type == ISEQ_TYPE_BLOCK) {
4697 const rb_iseq_t *local_iseq = ISEQ_BODY(CFP_ISEQ(cfp))->local_iseq;
4700 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
4701 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
4705 }
while (CFP_ISEQ(cfp) != local_iseq && !VM_FRAME_BMETHOD_P(cfp));
4710static const rb_callable_method_entry_t *
4711refined_method_callable_without_refinement(
const rb_callable_method_entry_t *me)
4713 const rb_method_entry_t *orig_me = me->def->body.refined.orig_me;
4714 const rb_callable_method_entry_t *cme;
4716 if (orig_me->defined_class == 0) {
4721 cme = (
const rb_callable_method_entry_t *)orig_me;
4724 VM_ASSERT(callable_method_entry_p(cme));
4726 if (UNDEFINED_METHOD_ENTRY_P(cme)) {
4739module_refinement_iclass(
VALUE refinement_iclass,
VALUE defined_class)
4744 VALUE cache = RCLASS_MODULE_REFINEMENT_ICLASSES(defined_class);
4746 if (LIKELY(cache)) {
4747 module_ref_iclass = rb_wmap_lookup(cache, refinement_iclass);
4750 cache = rb_wmap_new_hidden();
4751 RCLASS_SET_MODULE_REFINEMENT_ICLASSES(defined_class, cache);
4754 if (UNDEF_P(module_ref_iclass)) {
4758 if (RICLASS_FOR_REFINEMENT_P(refinement_iclass_super)) {
4759 super = module_refinement_iclass(refinement_iclass_super, defined_class);
4762 super = defined_class;
4765 module_ref_iclass = rb_include_class_new(
RBASIC(refinement_iclass)->klass, super);
4766 RCLASS_SET_REFINED_CLASS(module_ref_iclass, RCLASS_REFINED_CLASS(refinement_iclass));
4767 rb_class_subclass_add(RCLASS_REFINED_CLASS(refinement_iclass), module_ref_iclass);
4768 rb_wmap_aset(cache, refinement_iclass, module_ref_iclass);
4772 return module_ref_iclass;
4776rb_vm_module_refinement_iclass(
VALUE refinement_iclass,
VALUE defined_class)
4778 return module_refinement_iclass(refinement_iclass, defined_class);
4782refinement_iclass_for_cme(
VALUE refinement_iclass,
const rb_callable_method_entry_t *cme)
4785 refinement_iclass = module_refinement_iclass(refinement_iclass, cme->defined_class);
4787 return refinement_iclass;
4791rb_vm_refinement_iclass_for_cme(
VALUE refinement_iclass,
const rb_callable_method_entry_t *cme)
4793 return refinement_iclass_for_cme(refinement_iclass, cme);
4796static const rb_callable_method_entry_t *
4797search_refined_method(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4800 ID mid = vm_ci_mid(ci);
4802 const rb_cref_t *cref = (vm_ci_flag(ci) & VM_CALL_IGNORE_REFINEMENTS) ? NULL : vm_get_cref(cfp->ep);
4804 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4806 for (; cref; cref = CREF_NEXT(cref)) {
4807 VALUE refinement = find_refinement(CREF_REFINEMENTS(cref), vm_cc_cme(cc)->owner);
4808 if (
NIL_P(refinement))
continue;
4810 refinement = refinement_iclass_for_cme(refinement, vm_cc_cme(cc));
4812 const rb_callable_method_entry_t *
const ref_me =
4813 rb_callable_method_entry(refinement, mid);
4816 if (vm_cc_call(cc) == vm_call_super_method) {
4817 const rb_control_frame_t *top_cfp = current_method_entry(ec, cfp);
4818 const rb_callable_method_entry_t *top_me = rb_vm_frame_method_entry(top_cfp);
4819 if (top_me && rb_method_definition_eq(ref_me->def, top_me->def)) {
4824 if (cme->def->type != VM_METHOD_TYPE_REFINED ||
4825 cme->def != ref_me->def) {
4828 if (ref_me->def->type != VM_METHOD_TYPE_REFINED) {
4837 if (vm_cc_cme(cc)->def->body.refined.orig_me) {
4838 return refined_method_callable_without_refinement(vm_cc_cme(cc));
4842 const rb_callable_method_entry_t *cme = klass ? rb_callable_method_entry(klass, mid) : NULL;
4848vm_call_refined(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
4850 const rb_callable_method_entry_t *ref_cme = search_refined_method(ec, cfp, calling);
4853 if (calling->cd->cc) {
4854 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);
4856 return vm_call_method(ec, cfp, calling);
4859 struct rb_callcache *ref_cc = &VM_CC_ON_STACK(
Qundef, vm_call_general, {{ 0 }}, ref_cme);
4860 calling->cc= ref_cc;
4861 return vm_call_method(ec, cfp, calling);
4865 return vm_call_method_nome(ec, cfp, calling);
4869static 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);
4871NOINLINE(
static VALUE
4872 vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4876vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4879 int argc = calling->argc;
4882 if (argc > 0)
MEMMOVE(&TOPN(argc), &TOPN(argc-1),
VALUE, argc);
4885 return vm_invoke_block(ec, reg_cfp, calling, ci,
false, block_handler);
4889vm_call_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4891 RB_DEBUG_COUNTER_INC(ccf_opt_call);
4894 VALUE procval = calling->recv;
4895 return vm_invoke_block_opt_call(ec, reg_cfp, calling, ci, VM_BH_FROM_PROC(procval));
4899vm_call_opt_block_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4901 RB_DEBUG_COUNTER_INC(ccf_opt_block_call);
4903 VALUE block_handler = VM_ENV_BLOCK_HANDLER(VM_CF_LEP(reg_cfp));
4906 enum ruby_basic_operators bop;
4907 switch (vm_ci_mid(ci)) {
4908 case idAREF: bop = BOP_AREF;
break;
4909 case idYield: bop = BOP_YIELD;
break;
4910 case idEqq: bop = BOP_EQQ;
break;
4911 default: bop = BOP_CALL;
break;
4914 if (BASIC_OP_UNREDEFINED_P(bop, PROC_REDEFINED_OP_FLAG)) {
4915 return vm_invoke_block_opt_call(ec, reg_cfp, calling, ci, block_handler);
4918 calling->recv = rb_vm_bh_to_procval(ec, block_handler);
4919 calling->cc = rb_vm_search_method_slowpath(ci,
CLASS_OF(calling->recv));
4920 return vm_call_general(ec, reg_cfp, calling);
4925vm_call_opt_struct_aref0(rb_execution_context_t *ec,
struct rb_calling_info *calling)
4927 VALUE recv = calling->recv;
4930 VM_ASSERT(vm_cc_cme(calling->cc)->def->type == VM_METHOD_TYPE_OPTIMIZED);
4931 VM_ASSERT(vm_cc_cme(calling->cc)->def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_AREF);
4933 const unsigned int off = vm_cc_cme(calling->cc)->def->body.optimized.index;
4934 return RSTRUCT_GET_RAW(recv,
off);
4938vm_call_opt_struct_aref(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4940 RB_DEBUG_COUNTER_INC(ccf_opt_struct_aref);
4942 VALUE ret = vm_call_opt_struct_aref0(ec, calling);
4948vm_call_opt_struct_aset0(rb_execution_context_t *ec,
struct rb_calling_info *calling,
VALUE val)
4950 VALUE recv = calling->recv;
4953 VM_ASSERT(vm_cc_cme(calling->cc)->def->type == VM_METHOD_TYPE_OPTIMIZED);
4954 VM_ASSERT(vm_cc_cme(calling->cc)->def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_ASET);
4956 rb_check_frozen(recv);
4958 const unsigned int off = vm_cc_cme(calling->cc)->def->body.optimized.index;
4959 RSTRUCT_SET_RAW(recv,
off, val);
4965vm_call_opt_struct_aset(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
4967 RB_DEBUG_COUNTER_INC(ccf_opt_struct_aset);
4969 VALUE ret = vm_call_opt_struct_aset0(ec, calling, *(reg_cfp->sp - 1));
4974NOINLINE(
static VALUE vm_call_optimized(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
4977#define VM_CALL_METHOD_ATTR(var, func, nohook) \
4978 if (UNLIKELY(ruby_vm_c_events_enabled > 0)) { \
4979 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_CALL, calling->recv, vm_cc_cme(cc)->def->original_id, \
4980 vm_ci_mid(ci), vm_cc_cme(cc)->owner, Qundef); \
4982 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, calling->recv, vm_cc_cme(cc)->def->original_id, \
4983 vm_ci_mid(ci), vm_cc_cme(cc)->owner, (var)); \
4991vm_call_optimized(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling,
4994 switch (vm_cc_cme(cc)->def->body.optimized.type) {
4995 case OPTIMIZED_METHOD_TYPE_SEND:
4996 CC_SET_FASTPATH(cc, vm_call_opt_send, TRUE);
4997 return vm_call_opt_send(ec, cfp, calling);
4998 case OPTIMIZED_METHOD_TYPE_CALL:
4999 CC_SET_FASTPATH(cc, vm_call_opt_call, TRUE);
5000 return vm_call_opt_call(ec, cfp, calling);
5001 case OPTIMIZED_METHOD_TYPE_BLOCK_CALL:
5002 CC_SET_FASTPATH(cc, vm_call_opt_block_call, TRUE);
5003 return vm_call_opt_block_call(ec, cfp, calling);
5004 case OPTIMIZED_METHOD_TYPE_STRUCT_AREF: {
5005 CALLER_SETUP_ARG(cfp, calling, ci, 0);
5009 VM_CALL_METHOD_ATTR(v,
5010 vm_call_opt_struct_aref(ec, cfp, calling),
5011 set_vm_cc_ivar(cc); \
5012 CC_SET_FASTPATH(cc, vm_call_opt_struct_aref, (vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE)))
5015 case OPTIMIZED_METHOD_TYPE_STRUCT_ASET: {
5016 CALLER_SETUP_ARG(cfp, calling, ci, 1);
5020 VM_CALL_METHOD_ATTR(v,
5021 vm_call_opt_struct_aset(ec, cfp, calling),
5022 set_vm_cc_ivar(cc); \
5023 CC_SET_FASTPATH(cc, vm_call_opt_struct_aset, (vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE)))
5027 rb_bug(
"vm_call_method: unsupported optimized method type (%d)", vm_cc_cme(cc)->def->body.optimized.type);
5032vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
5036 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
5039 VM_ASSERT(! METHOD_ENTRY_INVALIDATED(cme));
5041 switch (cme->def->type) {
5042 case VM_METHOD_TYPE_ISEQ:
5043 if (ISEQ_BODY(def_iseq_ptr(cme->def))->param.flags.forwardable) {
5044 CC_SET_FASTPATH(cc, vm_call_iseq_fwd_setup, TRUE);
5045 return vm_call_iseq_fwd_setup(ec, cfp, calling);
5048 CC_SET_FASTPATH(cc, vm_call_iseq_setup, TRUE);
5049 return vm_call_iseq_setup(ec, cfp, calling);
5052 case VM_METHOD_TYPE_NOTIMPLEMENTED:
5053 case VM_METHOD_TYPE_CFUNC:
5054 CC_SET_FASTPATH(cc, vm_call_cfunc, TRUE);
5055 return vm_call_cfunc(ec, cfp, calling);
5057 case VM_METHOD_TYPE_ATTRSET:
5058 CALLER_SETUP_ARG(cfp, calling, ci, 1);
5062 const unsigned int aset_mask = (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT | VM_CALL_KWARG | VM_CALL_FORWARDING);
5064 if (vm_cc_markable(cc)) {
5065 vm_cc_attr_index_set(cc, IVAR_CACHE_INIT);
5066 VM_CALL_METHOD_ATTR(v,
5067 vm_call_attrset_direct(ec, cfp, cc, calling->recv),
5068 CC_SET_FASTPATH(cc, vm_call_attrset, !(vm_ci_flag(ci) & aset_mask)));
5074 VM_CALLCACHE_UNMARKABLE |
5075 VM_CALLCACHE_ON_STACK,
5081 .value = IVAR_CACHE_INIT,
5086 VM_CALL_METHOD_ATTR(v,
5087 vm_call_attrset_direct(ec, cfp, cc, calling->recv),
5088 CC_SET_FASTPATH(cc, vm_call_attrset, !(vm_ci_flag(ci) & aset_mask)));
5092 case VM_METHOD_TYPE_IVAR:
5093 CALLER_SETUP_ARG(cfp, calling, ci, 0);
5095 vm_cc_attr_index_set(cc, rb_getivar_cache_pack(ROOT_SHAPE_ID, ATTR_INDEX_NOT_SET));
5096 const unsigned int ivar_mask = (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT | VM_CALL_FORWARDING);
5097 VM_CALL_METHOD_ATTR(v,
5098 vm_call_ivar(ec, cfp, calling),
5099 CC_SET_FASTPATH(cc, vm_call_ivar, !(vm_ci_flag(ci) & ivar_mask)));
5102 case VM_METHOD_TYPE_MISSING:
5103 vm_cc_method_missing_reason_set(cc, 0);
5104 CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);
5105 return vm_call_method_missing(ec, cfp, calling);
5107 case VM_METHOD_TYPE_BMETHOD:
5108 CC_SET_FASTPATH(cc, vm_call_bmethod, TRUE);
5109 return vm_call_bmethod(ec, cfp, calling);
5111 case VM_METHOD_TYPE_ALIAS:
5112 CC_SET_FASTPATH(cc, vm_call_alias, TRUE);
5113 return vm_call_alias(ec, cfp, calling);
5115 case VM_METHOD_TYPE_OPTIMIZED:
5116 return vm_call_optimized(ec, cfp, calling, ci, cc);
5118 case VM_METHOD_TYPE_UNDEF:
5121 case VM_METHOD_TYPE_ZSUPER:
5122 return vm_call_zsuper(ec, cfp, calling, RCLASS_ORIGIN(vm_cc_cme(cc)->defined_class));
5124 case VM_METHOD_TYPE_REFINED:
5127 return vm_call_refined(ec, cfp, calling);
5130 rb_bug(
"vm_call_method: unsupported method type (%d)", vm_cc_cme(cc)->def->type);
5133NORETURN(
static void vm_raise_method_missing(rb_execution_context_t *ec,
int argc,
const VALUE *argv,
VALUE obj,
int call_status));
5136vm_call_method_nome(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
5140 const int stat = ci_missing_reason(ci);
5142 if (vm_ci_mid(ci) == idMethodMissing) {
5143 if (UNLIKELY(calling->heap_argv)) {
5147 rb_control_frame_t *reg_cfp = cfp;
5148 VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);
5149 vm_raise_method_missing(ec, calling->argc, argv, calling->recv, stat);
5153 return vm_call_method_missing_body(ec, cfp, calling, ci, stat);
5163vm_defined_class_for_protected_call(
const rb_callable_method_entry_t *me)
5165 VALUE defined_class = me->defined_class;
5166 VALUE refined_class = RCLASS_REFINED_CLASS(defined_class);
5167 return NIL_P(refined_class) ? defined_class : refined_class;
5171vm_call_method(rb_execution_context_t *ec, rb_control_frame_t *cfp,
struct rb_calling_info *calling)
5176 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
5178 if (vm_cc_cme(cc) != NULL) {
5179 switch (METHOD_ENTRY_VISI(vm_cc_cme(cc))) {
5180 case METHOD_VISI_PUBLIC:
5181 return vm_call_method_each_type(ec, cfp, calling);
5183 case METHOD_VISI_PRIVATE:
5184 if (!(vm_ci_flag(ci) & VM_CALL_FCALL)) {
5185 enum method_missing_reason stat = MISSING_PRIVATE;
5186 if (vm_ci_flag(ci) & VM_CALL_VCALL) stat |= MISSING_VCALL;
5188 vm_cc_method_missing_reason_set(cc, stat);
5189 CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);
5190 return vm_call_method_missing(ec, cfp, calling);
5192 return vm_call_method_each_type(ec, cfp, calling);
5194 case METHOD_VISI_PROTECTED:
5195 if (!(vm_ci_flag(ci) & (VM_CALL_OPT_SEND | VM_CALL_FCALL))) {
5196 VALUE defined_class = vm_defined_class_for_protected_call(vm_cc_cme(cc));
5198 vm_cc_method_missing_reason_set(cc, MISSING_PROTECTED);
5199 return vm_call_method_missing(ec, cfp, calling);
5203 VM_ASSERT(vm_cc_cme(cc) != NULL);
5206 calling->cc = &cc_on_stack;
5207 return vm_call_method_each_type(ec, cfp, calling);
5210 return vm_call_method_each_type(ec, cfp, calling);
5213 rb_bug(
"unreachable");
5217 return vm_call_method_nome(ec, cfp, calling);
5222vm_call_general(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
5224 RB_DEBUG_COUNTER_INC(ccf_general);
5225 return vm_call_method(ec, reg_cfp, calling);
5231 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
5232 VM_ASSERT(cc != vm_cc_empty());
5234 *(vm_call_handler *)&cc->call_ = vm_call_general;
5238vm_call_super_method(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
struct rb_calling_info *calling)
5240 RB_DEBUG_COUNTER_INC(ccf_super_method);
5245 if (ec == NULL) rb_bug(
"unreachable");
5248 VM_ASSERT(vm_cc_call(calling->cc) == vm_call_super_method);
5249 return vm_call_method(ec, reg_cfp, calling);
5255vm_search_normal_superclass(
VALUE klass)
5257 if (RICLASS_FOR_REFINEMENT_P(klass)) {
5261 }
while (RICLASS_FOR_REFINEMENT_P(klass));
5266 klass =
RBASIC(klass)->klass;
5268 klass = RCLASS_ORIGIN(klass);
5272NORETURN(
static void vm_super_outside(
void));
5275vm_super_outside(
void)
5281empty_cc_for_super(
void)
5283 return &rb_vm_empty_cc_for_super;
5287vm_search_super_method(
const rb_control_frame_t *reg_cfp,
struct rb_call_data *cd,
VALUE recv)
5289 VALUE current_defined_class;
5290 const rb_iseq_t *iseq = CFP_ISEQ(reg_cfp);
5291 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(reg_cfp);
5297 current_defined_class = vm_defined_class_for_protected_call(me);
5300 iseq != method_entry_iseqptr(me) &&
5303 RCLASS_INCLUDER(current_defined_class) : current_defined_class;
5307 "self has wrong type to call super in this context: "
5308 "%"PRIsVALUE
" (expected %"PRIsVALUE
")",
5313 if (me->def->type == VM_METHOD_TYPE_BMETHOD && (vm_ci_flag(cd->ci) & VM_CALL_ZSUPER)) {
5315 "implicit argument passing of super from method defined"
5316 " by define_method() is not supported."
5317 " Specify all arguments explicitly.");
5320 ID mid = me->def->original_id;
5322 if (!vm_ci_markable(cd->ci)) {
5323 VM_FORCE_WRITE((
const VALUE *)&cd->ci->mid, (
VALUE)mid);
5327 cd->ci = vm_ci_new_runtime(mid,
5330 vm_ci_kwarg(cd->ci));
5337 VALUE klass = vm_search_normal_superclass(me->defined_class);
5341 cc = vm_cc_new(
Qundef, NULL, vm_call_method_missing, cc_type_super);
5345 cc = vm_search_method_fastpath(reg_cfp, cd, klass);
5346 const rb_callable_method_entry_t *cached_cme = vm_cc_cme(cc);
5349 if (cached_cme == NULL) {
5351 cd->cc = empty_cc_for_super();
5353 else if (cached_cme->called_id != mid) {
5354 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, mid);
5356 cc = vm_cc_new(klass, cme, vm_call_super_method, cc_type_super);
5360 cd->cc = cc = empty_cc_for_super();
5364 switch (cached_cme->def->type) {
5366 case VM_METHOD_TYPE_REFINED:
5368 case VM_METHOD_TYPE_ATTRSET:
5369 case VM_METHOD_TYPE_IVAR:
5370 vm_cc_call_set(cc, vm_call_super_method);
5378 VM_ASSERT((vm_cc_cme(cc),
true));
5386block_proc_is_lambda(
const VALUE procval)
5391 GetProcPtr(procval, proc);
5392 return proc->header.is_lambda;
5400vm_yield_with_cfunc(rb_execution_context_t *ec,
5402 VALUE self,
int argc,
const VALUE *argv,
int kw_splat,
VALUE block_handler,
5403 const rb_callable_method_entry_t *me)
5405 int is_lambda = FALSE;
5406 VALUE val, arg, blockarg;
5408 const struct vm_ifunc *ifunc = captured->code.ifunc;
5413 else if (argc == 0) {
5420 blockarg = rb_vm_bh_to_procval(ec, block_handler);
5422 frame_flag = VM_FRAME_MAGIC_IFUNC | VM_FRAME_FLAG_CFRAME | (me ? VM_FRAME_FLAG_BMETHOD : 0);
5424 frame_flag |= VM_FRAME_FLAG_CFRAME_KW;
5427 vm_push_frame(ec, (
const rb_iseq_t *)captured->code.ifunc,
5430 VM_GUARDED_PREV_EP(captured->ep),
5432 0, ec->cfp->sp, 0, 0);
5433 val = (*ifunc->func)(arg, (
VALUE)ifunc->data, argc, argv, blockarg);
5434 rb_vm_pop_frame(ec);
5440rb_vm_yield_with_cfunc(rb_execution_context_t *ec,
const struct rb_captured_block *captured,
int argc,
const VALUE *argv)
5442 return vm_yield_with_cfunc(ec, captured, captured->self, argc, argv, 0, VM_BLOCK_HANDLER_NONE, NULL);
5446vm_yield_with_symbol(rb_execution_context_t *ec,
VALUE symbol,
int argc,
const VALUE *argv,
int kw_splat,
VALUE block_handler)
5448 VALUE passed_proc = rb_vm_bh_to_procval(ec, block_handler);
5450 if (!rb_box_available()) {
5451 return rb_sym_proc_call(
SYM2ID(symbol), argc, argv, kw_splat, passed_proc);
5454 const rb_control_frame_t *reg_cfp = ec->cfp;
5455 const rb_control_frame_t *ruby_cfp = rb_vm_get_ruby_level_next_cfp(ec, reg_cfp);
5456 const rb_box_t *box = NULL;
5463 box = current_box_on_cfp(ec, ruby_cfp);
5464 if (BOX_USER_P(box)) {
5467 ruby_cfp = rb_vm_get_ruby_level_next_cfp(ec, RUBY_VM_PREVIOUS_CONTROL_FRAME(ruby_cfp));
5471 if (!ruby_cfp || !box) {
5472 return rb_sym_proc_call(
SYM2ID(symbol), argc, argv, kw_splat, passed_proc);
5480 const rb_iseq_t *caller_iseq = CFP_ISEQ(ruby_cfp);
5481 VALUE name = rb_sprintf(
"block in %"PRIsVALUE, rb_iseq_label(caller_iseq));
5482 const rb_iseq_t *iseq = rb_iseq_new_with_opt(
Qnil, name,
5483 rb_iseq_path(caller_iseq), rb_iseq_realpath(caller_iseq),
5484 rb_vm_get_sourceline(ruby_cfp), caller_iseq, 0,
5485 ISEQ_TYPE_BLOCK, NULL,
Qnil);
5487 enum ruby_tag_type state;
5489 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_BLOCK | VM_FRAME_FLAG_FINISH,
5490 ruby_cfp->self, VM_GUARDED_PREV_EP(ruby_cfp->ep),
5492 ISEQ_BODY(iseq)->iseq_encoded, reg_cfp->sp,
5493 ISEQ_BODY(iseq)->local_table_size, ISEQ_BODY(iseq)->stack_max);
5501 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
5502 val = rb_sym_proc_call(
SYM2ID(symbol), argc, argv, kw_splat, passed_proc);
5506 if (state != TAG_NONE) {
5507 rb_vm_rewind_cfp(ec, (rb_control_frame_t *)reg_cfp);
5508 EC_JUMP_TAG(ec, state);
5511 rb_vm_pop_frame(ec);
5517vm_callee_setup_block_arg_arg0_splat(rb_control_frame_t *cfp,
const rb_iseq_t *iseq,
VALUE *argv,
VALUE ary)
5522 CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
5524 for (i=0; i<
len && i<ISEQ_BODY(iseq)->param.lead_num; i++) {
5532vm_callee_setup_block_arg_arg0_check(
VALUE *argv)
5534 VALUE ary, arg0 = argv[0];
5539 VM_ASSERT(argv[0] == arg0);
5545vm_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)
5547 if (rb_simple_iseq_p(iseq)) {
5548 rb_control_frame_t *cfp = ec->cfp;
5551 CALLER_SETUP_ARG(cfp, calling, ci, ISEQ_BODY(iseq)->param.lead_num);
5553 if (arg_setup_type == arg_setup_block &&
5554 calling->argc == 1 &&
5555 ISEQ_BODY(iseq)->param.flags.has_lead &&
5556 !ISEQ_BODY(iseq)->param.flags.ambiguous_param0 &&
5557 !
NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv))) {
5558 calling->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0);
5561 if (calling->argc != ISEQ_BODY(iseq)->param.lead_num) {
5562 if (arg_setup_type == arg_setup_block) {
5563 if (calling->argc < ISEQ_BODY(iseq)->param.lead_num) {
5565 CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
5566 for (i=calling->argc; i<ISEQ_BODY(iseq)->param.lead_num; i++) argv[i] =
Qnil;
5567 calling->argc = ISEQ_BODY(iseq)->param.lead_num;
5569 else if (calling->argc > ISEQ_BODY(iseq)->param.lead_num) {
5570 calling->argc = ISEQ_BODY(iseq)->param.lead_num;
5574 argument_arity_error(ec, iseq, NULL, calling->argc, ISEQ_BODY(iseq)->param.lead_num, ISEQ_BODY(iseq)->param.lead_num);
5581 return setup_parameters_complex(ec, iseq, calling, ci, argv, arg_setup_type);
5586vm_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)
5590 calling = &calling_entry;
5591 calling->argc = argc;
5592 calling->block_handler = block_handler;
5593 calling->kw_splat = (flags & VM_CALL_KW_SPLAT) ? 1 : 0;
5595 calling->heap_argv = 0;
5597 struct rb_callinfo dummy_ci = VM_CI_ON_STACK(0, flags, 0, 0);
5599 return vm_callee_setup_block_arg(ec, calling, &dummy_ci, iseq, argv, arg_setup_type);
5605vm_invoke_iseq_block_with_cref(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5607 bool is_lambda,
VALUE block_handler,
const rb_cref_t *cref)
5610 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
5611 const int arg_size = ISEQ_BODY(iseq)->param.size;
5612 VALUE *
const rsp = GET_SP() - calling->argc;
5613 VALUE *
const argv = rsp;
5614 int opt_pc = vm_callee_setup_block_arg(ec, calling, ci, iseq, argv, is_lambda ? arg_setup_method : arg_setup_block);
5615 int frame_flag = VM_FRAME_MAGIC_BLOCK | (is_lambda ? VM_FRAME_FLAG_LAMBDA : 0);
5620 vm_push_frame(ec, iseq,
5623 VM_GUARDED_PREV_EP(captured->ep), (
VALUE)cref,
5624 ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
5626 ISEQ_BODY(iseq)->local_table_size - arg_size, ISEQ_BODY(iseq)->stack_max);
5632vm_invoke_iseq_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5634 bool is_lambda,
VALUE block_handler)
5636 return vm_invoke_iseq_block_with_cref(ec, reg_cfp, calling, ci, is_lambda, block_handler, NULL);
5640vm_invoke_symbol_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5642 MAYBE_UNUSED(
bool is_lambda),
VALUE block_handler)
5644 VALUE symbol = VM_BH_TO_SYMBOL(block_handler);
5645 int flags = vm_ci_flag(ci);
5647 if (UNLIKELY(!(flags & VM_CALL_ARGS_SIMPLE) &&
5648 ((calling->argc == 0) ||
5649 (calling->argc == 1 && (flags & (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT))) ||
5650 (calling->argc == 2 && (flags & VM_CALL_ARGS_SPLAT) && (flags & VM_CALL_KW_SPLAT)) ||
5651 ((flags & VM_CALL_KWARG) && (vm_ci_kwarg(ci)->keyword_len == calling->argc))))) {
5652 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV);
5654 if (UNLIKELY(calling->heap_argv)) {
5655#if VM_ARGC_STACK_MAX < 0
5657 rb_raise(rb_eArgError,
"no receiver given");
5663 reg_cfp->sp[-1] = reg_cfp->sp[-2];
5664 reg_cfp->sp[-2] = calling->recv;
5665 flags |= VM_CALL_ARGS_SPLAT;
5668 if (calling->argc < 1) {
5669 rb_raise(rb_eArgError,
"no receiver given");
5671 calling->recv = TOPN(--calling->argc);
5673 if (calling->kw_splat) {
5674 flags |= VM_CALL_KW_SPLAT;
5678 if (calling->argc < 1) {
5679 rb_raise(rb_eArgError,
"no receiver given");
5681 calling->recv = TOPN(--calling->argc);
5684 return vm_call_symbol(ec, reg_cfp, calling, ci, symbol, flags);
5688vm_invoke_ifunc_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5690 MAYBE_UNUSED(
bool is_lambda),
VALUE block_handler)
5695 CALLER_SETUP_ARG(ec->cfp, calling, ci, ALLOW_HEAP_ARGV_KEEP_KWSPLAT);
5696 argc = calling->argc;
5697 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);
5703vm_block_to_block_handler(
const struct rb_block *block)
5705 switch (vm_block_type(block)) {
5706 case block_type_iseq:
5707 return VM_BH_FROM_ISEQ_BLOCK(&block->as.captured);
5708 case block_type_ifunc:
5709 return VM_BH_FROM_IFUNC_BLOCK(&block->as.captured);
5710 case block_type_symbol:
5711 return VM_BH_FROM_SYMBOL(block->as.symbol);
5712 case block_type_proc:
5713 return VM_BH_FROM_PROC(block->as.proc);
5715 VM_UNREACHABLE(vm_yield_with_proc);
5720vm_proc_to_block_handler(
VALUE procval)
5722 return vm_block_to_block_handler(vm_proc_block(procval));
5725NOINLINE(
static VALUE
5726vm_invoke_proc_block_with_cref(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5728 bool is_lambda,
VALUE block_handler,
VALUE refined_procval));
5730vm_invoke_proc_block_with_cref(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5732 bool is_lambda,
VALUE block_handler,
VALUE refined_procval)
5734 const rb_cref_t *cref = rb_proc_refinements_cref_for_call(refined_procval);
5735 return vm_invoke_iseq_block_with_cref(ec, reg_cfp, calling, ci, is_lambda, block_handler, cref);
5739vm_invoke_proc_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5741 bool is_lambda,
VALUE block_handler)
5743 VALUE refined_procval = 0;
5745 while (vm_block_handler_type(block_handler) == block_handler_type_proc) {
5746 VALUE procval = VM_BH_TO_PROC(block_handler);
5748 GetProcPtr(procval, po);
5749 if (po->header.is_refined) refined_procval = procval;
5750 is_lambda = po->header.is_lambda;
5751 block_handler = vm_block_to_block_handler(&po->block);
5754 if (UNLIKELY(refined_procval) && vm_block_handler_type(block_handler) == block_handler_type_iseq) {
5756 return vm_invoke_proc_block_with_cref(ec, reg_cfp, calling, ci, is_lambda, block_handler,
5760 return vm_invoke_block(ec, reg_cfp, calling, ci, is_lambda, block_handler);
5764vm_invoke_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5766 bool is_lambda,
VALUE block_handler)
5768 VALUE (*func)(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5770 bool is_lambda,
VALUE block_handler);
5772 switch (vm_block_handler_type(block_handler)) {
5773 case block_handler_type_iseq: func = vm_invoke_iseq_block;
break;
5774 case block_handler_type_ifunc: func = vm_invoke_ifunc_block;
break;
5775 case block_handler_type_proc: func = vm_invoke_proc_block;
break;
5776 case block_handler_type_symbol: func = vm_invoke_symbol_block;
break;
5777 default: rb_bug(
"vm_invoke_block: unreachable");
5780 return func(ec, reg_cfp, calling, ci, is_lambda, block_handler);
5784vm_make_proc_with_iseq(
const rb_iseq_t *blockiseq)
5786 const rb_execution_context_t *ec = GET_EC();
5787 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
5791 rb_bug(
"vm_make_proc_with_iseq: unreachable");
5794 captured = VM_CFP_TO_CAPTURED_BLOCK(cfp);
5795 captured->code.iseq = blockiseq;
5797 return rb_vm_make_proc(ec, captured,
rb_cProc);
5801vm_once_exec(
VALUE iseq)
5803 VALUE proc = vm_make_proc_with_iseq((rb_iseq_t *)iseq);
5807#define RUNNING_THREAD_ONCE_DONE ((rb_thread_t *)0x1)
5815vm_once_broadcast(rb_vm_t *vm)
5823vm_once_wait_no_gvl(
void *ptr)
5826 rb_vm_t *vm = arg->vm;
5827 rb_thread_t *running_th;
5830 running_th = rbimpl_atomic_ptr_load((
void **)&arg->is->once.running_thread, RBIMPL_ATOMIC_ACQUIRE);
5831 if (running_th != NULL && running_th != RUNNING_THREAD_ONCE_DONE) {
5839vm_once_wait_ubf(
void *ptr)
5841 vm_once_broadcast((rb_vm_t *)ptr);
5845vm_once_clear(
VALUE data)
5848 rbimpl_atomic_ptr_store((
volatile void **)&is->once.running_thread, NULL, RBIMPL_ATOMIC_RELEASE);
5849 vm_once_broadcast(GET_VM());
5861 args[0] = obj; args[1] =
Qfalse;
5863 if (!UNDEF_P(r) &&
RTEST(r)) {
5872vm_defined(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t op_type,
VALUE obj,
VALUE v)
5875 enum defined_type
type = (
enum defined_type)op_type;
5882 return rb_gvar_defined(
SYM2ID(obj));
5884 case DEFINED_CVAR: {
5885 const rb_cref_t *cref = vm_get_cref(GET_EP());
5886 klass = vm_get_cvar_base(cref, GET_CFP(), 0);
5891 case DEFINED_CONST_FROM: {
5892 bool allow_nil =
type == DEFINED_CONST;
5894 return vm_get_ev_const(ec, klass,
SYM2ID(obj), allow_nil,
true);
5899 return rb_ec_obj_respond_to(ec, v,
SYM2ID(obj), TRUE);
5901 case DEFINED_METHOD:{
5903 const rb_callable_method_entry_t *cme = rb_callable_method_entry_with_refinements(klass,
SYM2ID(obj), NULL);
5906 switch (METHOD_ENTRY_VISI(cme)) {
5907 case METHOD_VISI_PRIVATE:
5909 case METHOD_VISI_PROTECTED:
5913 case METHOD_VISI_PUBLIC:
5917 rb_bug(
"vm_defined: unreachable: %u", (
unsigned int)METHOD_ENTRY_VISI(cme));
5921 return check_respond_to_missing(obj, v);
5926 if (GET_BLOCK_HANDLER() != VM_BLOCK_HANDLER_NONE) {
5930 case DEFINED_ZSUPER:
5932 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(GET_CFP());
5935 VALUE klass = vm_search_normal_superclass(me->defined_class);
5936 if (!klass)
return false;
5938 ID id = me->def->original_id;
5945 return RTEST(vm_backref_defined(ec, GET_LEP(),
FIX2INT(obj)));
5947 rb_bug(
"unimplemented defined? type (VM)");
5955rb_vm_defined(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t op_type,
VALUE obj,
VALUE v)
5957 return vm_defined(ec, reg_cfp, op_type, obj, v);
5961vm_get_ep(
const VALUE *
const reg_ep, rb_num_t lv)
5964 const VALUE *ep = reg_ep;
5965 for (i = 0; i < lv; i++) {
5966 ep = GET_PREV_EP(ep);
5972vm_get_special_object(
const VALUE *
const reg_ep,
5973 enum vm_special_object_type
type)
5976 case VM_SPECIAL_OBJECT_VMCORE:
5977 return rb_mRubyVMFrozenCore;
5978 case VM_SPECIAL_OBJECT_CBASE:
5979 return vm_get_cbase(reg_ep);
5980 case VM_SPECIAL_OBJECT_CONST_BASE:
5981 return vm_get_const_base(reg_ep);
5983 rb_bug(
"putspecialobject insn: unknown value_type %d",
type);
5990rb_vm_get_special_object(
const VALUE *reg_ep,
enum vm_special_object_type
type)
5992 return vm_get_special_object(reg_ep,
type);
5998 const VALUE ary2 = ary2st;
5999 VALUE tmp1 = rb_check_to_array(ary1);
6000 VALUE tmp2 = rb_check_to_array(ary2);
6021 const VALUE ary2 = ary2st;
6023 if (
NIL_P(ary2))
return ary1;
6025 VALUE tmp2 = rb_check_to_array(ary2);
6040 return vm_concat_array(ary1, ary2st);
6044rb_vm_concat_to_array(
VALUE ary1,
VALUE ary2st)
6046 return vm_concat_to_array(ary1, ary2st);
6055 VALUE tmp = rb_check_to_array(ary);
6059 else if (
RTEST(flag)) {
6072 return vm_splat_array(flag, ary);
6076vm_check_match(rb_execution_context_t *ec,
VALUE target,
VALUE pattern, rb_num_t flag)
6078 enum vm_check_match_type
type = ((int)flag) & VM_CHECKMATCH_TYPE_MASK;
6080 if (flag & VM_CHECKMATCH_ARRAY) {
6084 for (i = 0; i < n; i++) {
6086 VALUE c = check_match(ec, v, target,
type);
6095 return check_match(ec, pattern, target,
type);
6100rb_vm_check_match(rb_execution_context_t *ec,
VALUE target,
VALUE pattern, rb_num_t flag)
6102 return vm_check_match(ec, target, pattern, flag);
6106vm_check_keyword(lindex_t bits, lindex_t idx,
const VALUE *ep)
6108 const VALUE kw_bits = *(ep - bits);
6111 unsigned int b = (
unsigned int)
FIX2ULONG(kw_bits);
6112 if ((idx < VM_KW_SPECIFIED_BITS_MAX) && (b & (0x01 << idx)))
6116 VM_ASSERT(rb_set_p(kw_bits),
"%s", rb_obj_info(kw_bits));
6125 if (RUBY_DTRACE_METHOD_ENTRY_ENABLED() ||
6126 RUBY_DTRACE_METHOD_RETURN_ENABLED() ||
6127 RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() ||
6128 RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) {
6132 RUBY_DTRACE_METHOD_ENTRY_HOOK(ec, 0, 0);
6135 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, 0, 0);
6138 RUBY_DTRACE_METHOD_RETURN_HOOK(ec, 0, 0);
6141 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, 0, 0);
6148vm_const_get_under(
ID id, rb_num_t flags,
VALUE cbase)
6153 else if (VM_DEFINECLASS_SCOPED_P(flags)) {
6154 return rb_public_const_get_at(cbase,
id);
6162vm_check_if_class(
ID id, rb_num_t flags,
VALUE super,
VALUE klass)
6167 else if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags)) {
6172 "superclass mismatch for class %"PRIsVALUE
"",
6185vm_check_if_module(
ID id,
VALUE mod)
6204vm_declare_class(
ID id, rb_num_t flags,
VALUE cbase,
VALUE super)
6207 VALUE s = VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) ? super :
rb_cObject;
6214vm_declare_module(
ID id,
VALUE cbase)
6220NORETURN(
static void unmatched_redefinition(
const char *
type,
VALUE cbase,
ID id,
VALUE old));
6224 VALUE name = rb_id2str(
id);
6225 VALUE message = rb_sprintf(
"%"PRIsVALUE
" is not a %s",
6227 VALUE location = rb_const_source_location_at(cbase,
id);
6228 if (!
NIL_P(location)) {
6229 rb_str_catf(message,
"\n%"PRIsVALUE
":%"PRIsVALUE
":"
6230 " previous definition of %"PRIsVALUE
" was here",
6237vm_define_class(
ID id, rb_num_t flags,
VALUE cbase,
VALUE super)
6241 if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) && !
RB_TYPE_P(super,
T_CLASS)) {
6243 "superclass must be an instance of Class (given an instance of %"PRIsVALUE
")",
6247 vm_check_if_namespace(cbase);
6252 if ((klass = vm_const_get_under(
id, flags, cbase)) != 0) {
6253 if (!vm_check_if_class(
id, flags, super, klass))
6254 unmatched_redefinition(
"class", cbase,
id, klass);
6258 return vm_declare_class(
id, flags, cbase, super);
6263vm_define_module(
ID id, rb_num_t flags,
VALUE cbase)
6267 vm_check_if_namespace(cbase);
6268 if ((mod = vm_const_get_under(
id, flags, cbase)) != 0) {
6269 if (!vm_check_if_module(
id, mod))
6270 unmatched_redefinition(
"module", cbase,
id, mod);
6274 return vm_declare_module(
id, cbase);
6279vm_find_or_create_class_by_id(
ID id,
6284 rb_vm_defineclass_type_t
type = VM_DEFINECLASS_TYPE(flags);
6287 case VM_DEFINECLASS_TYPE_CLASS:
6289 return vm_define_class(
id, flags, cbase, super);
6291 case VM_DEFINECLASS_TYPE_SINGLETON_CLASS:
6295 case VM_DEFINECLASS_TYPE_MODULE:
6297 return vm_define_module(
id, flags, cbase);
6300 rb_bug(
"unknown defineclass type: %d", (
int)
type);
6304static rb_method_visibility_t
6305vm_scope_visibility_get(
const rb_execution_context_t *ec)
6307 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
6309 if (!vm_env_cref_by_cref(cfp->ep)) {
6310 return METHOD_VISI_PUBLIC;
6313 return CREF_SCOPE_VISI(vm_ec_cref(ec))->method_visi;
6318vm_scope_module_func_check(
const rb_execution_context_t *ec)
6320 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
6322 if (!vm_env_cref_by_cref(cfp->ep)) {
6326 return CREF_SCOPE_VISI(vm_ec_cref(ec))->module_func;
6331vm_define_method(
const rb_execution_context_t *ec,
VALUE obj,
ID id,
VALUE iseqval,
int is_singleton)
6334 rb_method_visibility_t visi;
6335 rb_cref_t *cref = vm_ec_cref(ec);
6339 visi = METHOD_VISI_PUBLIC;
6342 klass = CREF_CLASS_FOR_DEFINITION(cref);
6343 visi = vm_scope_visibility_get(ec);
6350 rb_add_method_iseq(klass,
id, (
const rb_iseq_t *)iseqval, cref, visi);
6353 !RCLASS_SINGLETON_P(klass) && !RCLASS_EXPECT_NO_IVAR(klass) &&
6355 RCLASS_SET_MAX_IV_COUNT(klass, rb_estimate_iv_count(klass, (
const rb_iseq_t *)iseqval));
6358 if (!is_singleton && vm_scope_module_func_check(ec)) {
6360 rb_add_method_iseq(klass,
id, (
const rb_iseq_t *)iseqval, cref, METHOD_VISI_PUBLIC);
6369rb_vm_untag_block_handler(
VALUE block_handler)
6371 if (VM_BLOCK_HANDLER_NONE == block_handler)
return Qnil;
6373 switch (vm_block_handler_type(block_handler)) {
6374 case block_handler_type_iseq:
6375 case block_handler_type_ifunc: {
6377 return captured->code.val;
6379 case block_handler_type_proc:
6380 case block_handler_type_symbol:
6381 return block_handler;
6383 rb_bug(
"rb_vm_untag_block_handler: unreachable");
6388rb_vm_get_untagged_block_handler(rb_control_frame_t *reg_cfp)
6390 return rb_vm_untag_block_handler(VM_CF_BLOCK_HANDLER(reg_cfp));
6399 VALUE block_handler = VM_CF_BLOCK_HANDLER(GET_CFP());
6401 if (block_handler == VM_BLOCK_HANDLER_NONE) {
6402 rb_vm_localjump_error(
"no block given (yield)",
Qnil, 0);
6405 return vm_invoke_block(ec, GET_CFP(), calling, ci,
false, block_handler);
6409enum method_explorer_type {
6411 mexp_search_invokeblock,
6418 enum method_explorer_type method_explorer));
6424 VALUE block_handler,
6425 enum method_explorer_type method_explorer
6430 int argc = vm_ci_argc(ci);
6431 VALUE recv = TOPN(argc);
6433 .block_handler = block_handler,
6434 .kw_splat = IS_ARGS_KW_SPLAT(ci) > 0,
6440 switch (method_explorer) {
6441 case mexp_search_method:
6442 calling.cc = cc = vm_search_method_fastpath(reg_cfp, cd,
CLASS_OF(recv));
6443 val = vm_cc_call(cc)(ec, GET_CFP(), &calling);
6445 case mexp_search_super:
6446 calling.cc = cc = vm_search_super_method(reg_cfp, cd, recv);
6447 val = vm_cc_call(cc)(ec, GET_CFP(), &calling);
6449 case mexp_search_invokeblock:
6450 val = vm_invokeblock_i(ec, GET_CFP(), &calling);
6457rb_vm_send(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6460 VALUE bh = vm_caller_setup_arg_block(ec, GET_CFP(), cd->ci, blockiseq,
false);
6461 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_method);
6468rb_vm_sendforward(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6475 VALUE bh = vm_caller_setup_fwd_args(GET_EC(), GET_CFP(), cd, blockiseq,
false, &adjusted_cd, &adjusted_ci);
6477 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd.cd, bh, mexp_search_method);
6479 if (cd->cc != adjusted_cd.cd.cc && vm_cc_markable(adjusted_cd.cd.cc)) {
6480 RB_OBJ_WRITE(CFP_ISEQ(GET_CFP()), &cd->cc, adjusted_cd.cd.cc);
6488rb_vm_opt_send_without_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd)
6491 VALUE bh = VM_BLOCK_HANDLER_NONE;
6492 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_method);
6498rb_vm_invokesuper(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6502 struct rb_callinfo adjusted_ci = VM_CI_ON_STACK(vm_ci_mid(cd->ci),
6505 vm_ci_kwarg(cd->ci));
6506 const struct rb_callcache *original_cc = rbimpl_atomic_ptr_load((
void **)&cd->cc, RBIMPL_ATOMIC_ACQUIRE);
6512 VALUE bh = vm_caller_setup_arg_block(ec, GET_CFP(), adjusted_cd.ci, blockiseq,
true);
6513 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd, bh, mexp_search_super);
6515 if (original_cc != adjusted_cd.cc && vm_cc_markable(adjusted_cd.cc)) {
6516 rbimpl_atomic_ptr_store((
volatile void **)&cd->cc, (
void *)adjusted_cd.cc, RBIMPL_ATOMIC_RELEASE);
6526rb_vm_invokesuperforward(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6532 VALUE bh = vm_caller_setup_fwd_args(GET_EC(), GET_CFP(), cd, blockiseq,
true, &adjusted_cd, &adjusted_ci);
6534 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd.cd, bh, mexp_search_super);
6536 if (cd->cc != adjusted_cd.cd.cc && vm_cc_markable(adjusted_cd.cd.cc)) {
6537 RB_OBJ_WRITE(CFP_ISEQ(GET_CFP()), &cd->cc, adjusted_cd.cd.cc);
6545rb_vm_invokeblock(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd)
6548 VALUE bh = VM_BLOCK_HANDLER_NONE;
6549 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_invokeblock);
6577 if (check_method_basic_definition(cme)) {
6583 if (check_cfunc(cme, rb_mod_to_s)) {
6589 val = rb_mod_to_s(recv);
6595 if (check_cfunc(cme, rb_nil_to_s)) {
6596 return rb_nil_to_s(recv);
6600 if (check_cfunc(cme, rb_true_to_s)) {
6601 return rb_true_to_s(recv);
6605 if (check_cfunc(cme, rb_false_to_s)) {
6606 return rb_false_to_s(recv);
6610 if (check_cfunc(cme, rb_int_to_s)) {
6611 return rb_fix_to_s(recv);
6623 return vm_objtostring(reg_cfp, recv, cd);
6627vm_opt_ary_freeze(
VALUE ary,
int bop,
ID id)
6629 if (BASIC_OP_UNREDEFINED_P(bop, ARRAY_REDEFINED_OP_FLAG)) {
6638vm_opt_hash_freeze(
VALUE hash,
int bop,
ID id)
6640 if (BASIC_OP_UNREDEFINED_P(bop, HASH_REDEFINED_OP_FLAG)) {
6649vm_opt_str_freeze(
VALUE str,
int bop,
ID id)
6651 if (BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
6663vm_opt_duparray_include_p(rb_execution_context_t *ec,
const VALUE ary,
VALUE target)
6665 if (OP_UNREDEFINED_P(INCLUDE_P, ARRAY)) {
6669 VALUE args[1] = {target};
6672 RUBY_DTRACE_CREATE_HOOK(ARRAY,
RARRAY_LEN(ary));
6675 return rb_vm_call_with_refinements(ec, dupary, idIncludeP, 1, args,
RB_NO_KEYWORDS);
6680rb_vm_opt_duparray_include_p(rb_execution_context_t *ec,
const VALUE ary,
VALUE target)
6682 return vm_opt_duparray_include_p(ec, ary, target);
6686vm_opt_newarray_max(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr)
6688 if (OP_UNREDEFINED_P(MAX, ARRAY)) {
6689 if (array_len == 0) {
6693 VALUE result = *ptr;
6694 rb_snum_t i = array_len - 1;
6696 const VALUE v = *++ptr;
6697 if (OPTIMIZED_CMP(v, result) > 0) {
6710rb_vm_opt_newarray_max(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr)
6712 return vm_opt_newarray_max(ec, array_len, ptr);
6716vm_opt_newarray_min(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr)
6718 if (OP_UNREDEFINED_P(MIN, ARRAY)) {
6719 if (array_len == 0) {
6723 VALUE result = *ptr;
6724 rb_snum_t i = array_len - 1;
6726 const VALUE v = *++ptr;
6727 if (OPTIMIZED_CMP(v, result) < 0) {
6740rb_vm_opt_newarray_min(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr)
6742 return vm_opt_newarray_min(ec, array_len, ptr);
6746vm_opt_newarray_hash(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr)
6749 if (OP_UNREDEFINED_P(HASH, ARRAY)) {
6750 return rb_ary_hash_values(array_len, ptr);
6758rb_vm_opt_newarray_hash(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr)
6760 return vm_opt_newarray_hash(ec, array_len, ptr);
6767vm_opt_newarray_include_p(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr,
VALUE target)
6769 if (OP_UNREDEFINED_P(INCLUDE_P, ARRAY)) {
6770 struct RArray fake_ary = {RBASIC_INIT};
6771 VALUE ary = rb_setup_fake_ary(&fake_ary, ptr, array_len);
6775 VALUE args[1] = {target};
6781rb_vm_opt_newarray_include_p(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr,
VALUE target)
6783 return vm_opt_newarray_include_p(ec, array_len, ptr, target);
6787vm_opt_newarray_pack_buffer(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr,
VALUE fmt,
VALUE buffer)
6789 if (OP_UNREDEFINED_P(PACK, ARRAY)) {
6790 struct RArray fake_ary = {RBASIC_INIT};
6791 VALUE ary = rb_setup_fake_ary(&fake_ary, ptr, array_len);
6792 return rb_ec_pack_ary(ec,
ary, fmt, (UNDEF_P(buffer) ?
Qnil : buffer));
6802 if (!UNDEF_P(buffer)) {
6803 args[1] = rb_hash_new_capa(1);
6804 rb_hash_aset(args[1],
ID2SYM(idBuffer), buffer);
6809 return rb_vm_call_with_refinements(ec,
rb_ary_new4(array_len, ptr), idPack, argc, args, kw_splat);
6814rb_vm_opt_newarray_pack_buffer(rb_execution_context_t *ec, rb_num_t array_len,
const VALUE *ptr,
VALUE fmt,
VALUE buffer)
6816 return vm_opt_newarray_pack_buffer(ec, array_len, ptr, fmt, buffer);
6823vm_track_constant_cache(
ID id,
void *ic)
6825 rb_vm_t *vm = GET_VM();
6826 struct rb_id_table *const_cache = &vm->constant_cache;
6827 VALUE lookup_result;
6830 if (rb_id_table_lookup(const_cache,
id, &lookup_result)) {
6834 ics = set_init_numtable();
6835 rb_id_table_insert(const_cache,
id, (
VALUE)ics);
6850 vm->inserting_constant_cache_id = id;
6852 set_insert(ics, (st_data_t)ic);
6854 vm->inserting_constant_cache_id = (
ID)0;
6858vm_ic_track_const_chain(rb_control_frame_t *cfp, IC ic,
const ID *segments)
6861 for (
int i = 0; segments[i]; i++) {
6862 ID id = segments[i];
6863 if (
id == idNULL)
continue;
6864 vm_track_constant_cache(
id, ic);
6871vm_inlined_ic_hit_p(
VALUE flags,
VALUE value,
const rb_cref_t *ic_cref, rb_serial_t ractor_id,
const VALUE *reg_ep)
6875 if ((flags & IMEMO_CONST_CACHE_SHAREABLE) || ractor_id == rb_ractor_id(GET_RACTOR())) {
6876 VM_ASSERT(ractor_incidental_shareable_p(flags & IMEMO_CONST_CACHE_SHAREABLE, value));
6878 return (ic_cref == NULL ||
6879 ic_cref == vm_get_cref(reg_ep));
6887 VM_ASSERT(IMEMO_TYPE_P(ice, imemo_constcache));
6888 return vm_inlined_ic_hit_p(ice->flags, ice->value, ice->ic_cref, ice->ractor_id, reg_ep);
6893rb_vm_ic_hit_p(IC ic,
const VALUE *reg_ep)
6895 return ic->entry && vm_ic_hit_p(ic->entry, reg_ep);
6899vm_ic_update(
const rb_execution_context_t *ec,
const rb_iseq_t *iseq, IC ic,
VALUE val,
const VALUE *reg_ep,
const VALUE *pc)
6901 if (ruby_vm_const_missing_count > 0) {
6902 ruby_vm_const_missing_count = 0;
6909 ice->ic_cref = vm_get_const_key_cref(reg_ep);
6910 ice->ractor_id = rb_ractor_id(rb_ec_ractor_ptr(ec));
6914 ice->flags |= IMEMO_CONST_CACHE_SHAREABLE;
6918 unsigned pos = (unsigned)(pc - ISEQ_BODY(iseq)->iseq_encoded);
6919 rb_yjit_constant_ic_update(iseq, ic, pos);
6923rb_vm_opt_getconstant_path(rb_execution_context_t *ec, rb_control_frame_t *
const reg_cfp, IC ic)
6929 if (ice && vm_ic_hit_p(ice, GET_EP())) {
6936 VM_ASSERT(val == vm_get_ev_const_chain(ec, segments) || rb_multi_ractor_p());
6939 ruby_vm_constant_cache_misses++;
6940 val = vm_get_ev_const_chain(ec, segments);
6941 vm_ic_track_const_chain(GET_CFP(), ic, segments);
6944 vm_ic_update(ec, CFP_ISEQ(GET_CFP()), ic, val, GET_EP(), CFP_PC(GET_CFP()) - 2);
6953rb_vm_once_done_value(ISE is,
VALUE *result)
6955 rb_thread_t *running_th = rbimpl_atomic_ptr_load((
void**)&is->once.running_thread, RBIMPL_ATOMIC_ACQUIRE);
6956 if (running_th == RUNNING_THREAD_ONCE_DONE) {
6957 *result = is->once.value;
6964vm_once_dispatch(rb_execution_context_t *ec, ISEQ iseq, ISE is)
6966 rb_thread_t *th = rb_ec_thread_ptr(ec);
6967 rb_thread_t *running_th;
6970 running_th = rbimpl_atomic_ptr_load((
void**)&is->once.running_thread, RBIMPL_ATOMIC_ACQUIRE);
6971 if (running_th == RUNNING_THREAD_ONCE_DONE) {
6972 return is->once.value;
6974 else if (running_th == NULL) {
6976 enum ruby_tag_type state;
6977 if (rbimpl_atomic_ptr_cas((
void**)&is->once.running_thread, running_th, th, RBIMPL_ATOMIC_RELEASE, RBIMPL_ATOMIC_RELAXED) != running_th) {
6981 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
6982 val = vm_once_exec((
VALUE)iseq);
6985 if (state != TAG_NONE) {
6986 vm_once_clear((
VALUE)is);
6987 EC_JUMP_TAG(ec, state);
6997 rbimpl_atomic_ptr_store((
volatile void**)&is->once.running_thread, RUNNING_THREAD_ONCE_DONE, RBIMPL_ATOMIC_RELEASE);
6998 vm_once_broadcast(rb_ec_vm_ptr(ec));
7001 else if (running_th == th) {
7003 return vm_once_exec((
VALUE)iseq);
7008 rb_nogvl(vm_once_wait_no_gvl, &arg, vm_once_wait_ubf, arg.vm,
7010 RUBY_VM_CHECK_INTS(ec);
7016vm_case_dispatch(CDHASH hash, OFFSET else_offset,
VALUE key)
7018 switch (OBJ_BUILTIN_TYPE(key)) {
7024 if (BASIC_OP_UNREDEFINED_P(BOP_EQQ,
7025 SYMBOL_REDEFINED_OP_FLAG |
7026 INTEGER_REDEFINED_OP_FLAG |
7027 FLOAT_REDEFINED_OP_FLAG |
7028 NIL_REDEFINED_OP_FLAG |
7029 TRUE_REDEFINED_OP_FLAG |
7030 FALSE_REDEFINED_OP_FLAG |
7031 STRING_REDEFINED_OP_FLAG)) {
7035 if (!isinf(kval) && modf(kval, &kval) == 0.0) {
7039 if (st_lookup(rb_imemo_cdhash_tbl(hash), key, &val)) {
7051 vm_stack_consistency_error(
const rb_execution_context_t *ec,
7052 const rb_control_frame_t *,
7055vm_stack_consistency_error(
const rb_execution_context_t *ec,
7056 const rb_control_frame_t *cfp,
7059 const ptrdiff_t nsp = VM_SP_CNT(ec, cfp->sp);
7060 const ptrdiff_t nbp = VM_SP_CNT(ec, bp);
7061 static const char stack_consistency_error[] =
7062 "Stack consistency error (sp: %"PRIdPTRDIFF
", bp: %"PRIdPTRDIFF
")";
7063#if defined RUBY_DEVEL
7064 VALUE mesg = rb_sprintf(stack_consistency_error, nsp, nbp);
7069 rb_bug(stack_consistency_error, nsp, nbp);
7076 if (FIXNUM_2_P(recv, obj) &&
7077 OP_UNREDEFINED_P(PLUS, INTEGER)) {
7078 return rb_fix_plus_fix(recv, obj);
7080 else if (FLONUM_2_P(recv, obj) &&
7081 OP_UNREDEFINED_P(PLUS, FLOAT)) {
7089 OP_UNREDEFINED_P(PLUS, FLOAT)) {
7094 OP_UNREDEFINED_P(PLUS, STRING)) {
7095 return rb_str_opt_plus(recv, obj);
7099 OP_UNREDEFINED_P(PLUS, ARRAY)) {
7110 if (FIXNUM_2_P(recv, obj) &&
7111 OP_UNREDEFINED_P(MINUS, INTEGER)) {
7112 return rb_fix_minus_fix(recv, obj);
7114 else if (FLONUM_2_P(recv, obj) &&
7115 OP_UNREDEFINED_P(MINUS, FLOAT)) {
7123 OP_UNREDEFINED_P(MINUS, FLOAT)) {
7134 if (FIXNUM_2_P(recv, obj) &&
7135 OP_UNREDEFINED_P(MULT, INTEGER)) {
7136 return rb_fix_mul_fix(recv, obj);
7138 else if (FLONUM_2_P(recv, obj) &&
7139 OP_UNREDEFINED_P(MULT, FLOAT)) {
7147 OP_UNREDEFINED_P(MULT, FLOAT)) {
7158 if (FIXNUM_2_P(recv, obj) &&
7159 OP_UNREDEFINED_P(DIV, INTEGER)) {
7160 return (
FIX2LONG(obj) == 0) ?
Qundef : rb_fix_div_fix(recv, obj);
7162 else if (FLONUM_2_P(recv, obj) &&
7163 OP_UNREDEFINED_P(DIV, FLOAT)) {
7164 return rb_flo_div_flo(recv, obj);
7171 OP_UNREDEFINED_P(DIV, FLOAT)) {
7172 return rb_flo_div_flo(recv, obj);
7182 if (FIXNUM_2_P(recv, obj) &&
7183 OP_UNREDEFINED_P(MOD, INTEGER)) {
7184 return (
FIX2LONG(obj) == 0) ?
Qundef : rb_fix_mod_fix(recv, obj);
7186 else if (FLONUM_2_P(recv, obj) &&
7187 OP_UNREDEFINED_P(MOD, FLOAT)) {
7195 OP_UNREDEFINED_P(MOD, FLOAT)) {
7206 if (vm_method_cfunc_is(reg_cfp, cd, recv, rb_obj_not_equal)) {
7207 VALUE val = opt_equality(reg_cfp, recv, obj, cd_eq);
7209 if (!UNDEF_P(val)) {
7210 return RBOOL(!
RTEST(val));
7220 if (FIXNUM_2_P(recv, obj) &&
7221 OP_UNREDEFINED_P(LT, INTEGER)) {
7224 else if (FLONUM_2_P(recv, obj) &&
7225 OP_UNREDEFINED_P(LT, FLOAT)) {
7233 OP_UNREDEFINED_P(LT, FLOAT)) {
7244 if (FIXNUM_2_P(recv, obj) &&
7245 OP_UNREDEFINED_P(LE, INTEGER)) {
7248 else if (FLONUM_2_P(recv, obj) &&
7249 OP_UNREDEFINED_P(LE, FLOAT)) {
7257 OP_UNREDEFINED_P(LE, FLOAT)) {
7268 if (FIXNUM_2_P(recv, obj) &&
7269 OP_UNREDEFINED_P(GT, INTEGER)) {
7272 else if (FLONUM_2_P(recv, obj) &&
7273 OP_UNREDEFINED_P(GT, FLOAT)) {
7281 OP_UNREDEFINED_P(GT, FLOAT)) {
7292 if (FIXNUM_2_P(recv, obj) &&
7293 OP_UNREDEFINED_P(GE, INTEGER)) {
7296 else if (FLONUM_2_P(recv, obj) &&
7297 OP_UNREDEFINED_P(GE, FLOAT)) {
7305 OP_UNREDEFINED_P(GE, FLOAT)) {
7321 OP_UNREDEFINED_P(LTLT, STRING)) {
7330 OP_UNREDEFINED_P(LTLT, ARRAY)) {
7348 OP_UNREDEFINED_P(AND, INTEGER)) {
7359 if (FIXNUM_2_P(recv, obj) &&
7360 OP_UNREDEFINED_P(OR, INTEGER)) {
7372 if (FIXNUM_2_P(recv, obj) &&
7373 OP_UNREDEFINED_P(AREF, INTEGER)) {
7374 return rb_fix_aref(recv, obj);
7379 OP_UNREDEFINED_P(AREF, ARRAY)) {
7381 return rb_ary_entry_internal(recv,
FIX2LONG(obj));
7384 return rb_ary_aref1(recv, obj);
7388 OP_UNREDEFINED_P(AREF, HASH)) {
7389 return rb_hash_aref(recv, obj);
7403 OP_UNREDEFINED_P(ASET, ARRAY) &&
7409 OP_UNREDEFINED_P(ASET, HASH)) {
7410 rb_hash_aset(recv, obj, set);
7419vm_opt_length(
VALUE recv,
int bop)
7425 BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
7426 if (bop == BOP_EMPTY_P) {
7427 return LEN2NUM(RSTRING_LEN(recv));
7434 BASIC_OP_UNREDEFINED_P(bop, ARRAY_REDEFINED_OP_FLAG)) {
7438 BASIC_OP_UNREDEFINED_P(bop, HASH_REDEFINED_OP_FLAG)) {
7447vm_opt_empty_p(
VALUE recv)
7449 switch (vm_opt_length(recv, BOP_EMPTY_P)) {
7462 OP_UNREDEFINED_P(
NIL_P, NIL)) {
7465 else if (vm_method_cfunc_is(reg_cfp, cd, recv, rb_false)) {
7481 case RSHIFT(~0UL, 1):
7484 return rb_uint2big(1UL << (SIZEOF_LONG * CHAR_BIT - 2));
7502vm_opt_succ(
VALUE recv)
7505 OP_UNREDEFINED_P(SUCC, INTEGER)) {
7506 return fix_succ(recv);
7512 OP_UNREDEFINED_P(SUCC, STRING)) {
7523 if (vm_method_cfunc_is(reg_cfp, cd, recv, rb_obj_not)) {
7524 return RBOOL(!
RTEST(recv));
7539 OP_UNREDEFINED_P(MATCH, STRING)) {
7543 OP_UNREDEFINED_P(MATCH, REGEXP)) {
7551#undef EQ_UNREDEFINED_P
7552#undef OP_UNREDEFINED_P
7554rb_event_flag_t rb_iseq_event_flags(
const rb_iseq_t *iseq,
size_t pos);
7556NOINLINE(
static void vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp));
7559vm_trace_hook(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
const VALUE *pc,
7561 rb_hook_list_t *global_hooks, rb_hook_list_t *local_hooks,
VALUE val)
7564 VALUE self = GET_SELF();
7566 VM_ASSERT(rb_popcount64((uint64_t)event) == 1);
7568 if (local_hooks) local_hooks->running++;
7570 if (event & global_hooks->events) {
7573 vm_dtrace(event, ec);
7574 rb_exec_event_hook_orig(ec, global_hooks, event, self, 0, 0, 0 , val, 0);
7578 if (local_hooks) local_hooks->running--;
7579 if (local_hooks != NULL) {
7580 if (event & local_hooks->events) {
7583 rb_exec_event_hook_orig(ec, local_hooks, event, self, 0, 0, 0 , val, 0);
7593#define VM_TRACE_HOOK(target_event, val) do { \
7594 if ((pc_events & (target_event)) & enabled_flags) { \
7595 if (local_hooks_cnt > 0) local_hooks = rb_iseq_local_hooks(iseq, r, false); \
7596 vm_trace_hook(ec, reg_cfp, pc, pc_events, (target_event), global_hooks, local_hooks, (val)); \
7601rescue_errinfo(rb_execution_context_t *ec, rb_control_frame_t *cfp)
7603 VM_ASSERT(VM_FRAME_RUBYFRAME_P(cfp));
7604 VM_ASSERT(ISEQ_BODY(CFP_ISEQ(cfp))->
type == ISEQ_TYPE_RESCUE);
7605 return cfp->ep[VM_ENV_INDEX_LAST_LVAR];
7609vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp)
7611 const VALUE *pc = reg_cfp->pc;
7612 rb_ractor_t *r = rb_ec_ractor_ptr(ec);
7613 rb_event_flag_t enabled_flags = r->pub.hooks.events & ISEQ_TRACE_EVENTS;
7616 if (enabled_flags == 0 && rb_ractor_targeted_hooks_cnt(r) == 0) {
7620 const rb_iseq_t *iseq = CFP_ISEQ(reg_cfp);
7621 size_t pos = pc - ISEQ_BODY(iseq)->iseq_encoded;
7623 unsigned int local_hooks_cnt = iseq->aux.exec.local_hooks_cnt;
7624 rb_hook_list_t *local_hooks = NULL;
7625 if (RB_UNLIKELY(local_hooks_cnt > 0)) {
7627 if (st_lookup(rb_ractor_targeted_hooks(r), (st_data_t)iseq, &val)) {
7628 local_hooks = (rb_hook_list_t*)val;
7631 rb_event_flag_t iseq_local_events = local_hooks != NULL ? local_hooks->events : 0;
7633 rb_hook_list_t *bmethod_local_hooks = NULL;
7635 unsigned int bmethod_hooks_cnt = 0;
7636 rb_method_definition_t *bmethod_def = NULL;
7637 const bool bmethod_frame = VM_FRAME_BMETHOD_P(reg_cfp);
7638 enabled_flags |= iseq_local_events;
7640 VM_ASSERT((iseq_local_events & ~ISEQ_TRACE_EVENTS) == 0);
7642 if (bmethod_frame) {
7643 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(reg_cfp);
7644 VM_ASSERT(me->def->type == VM_METHOD_TYPE_BMETHOD);
7645 bmethod_def = me->def;
7646 bmethod_hooks_cnt = me->def->body.bmethod.local_hooks_cnt;
7647 if (RB_UNLIKELY(bmethod_hooks_cnt > 0)) {
7649 if (st_lookup(rb_ractor_targeted_hooks(r), (st_data_t)me->def, &val)) {
7650 bmethod_local_hooks = (rb_hook_list_t*)val;
7652 if (bmethod_local_hooks) {
7653 bmethod_local_events = bmethod_local_hooks->events;
7658 if ((pc_events & enabled_flags) == 0 && !bmethod_frame) {
7662 rb_iseq_trace_set(iseq, vm_event_flags & ISEQ_TRACE_EVENTS);
7670 else if (ec->trace_arg != NULL) {
7675 rb_hook_list_t *global_hooks = rb_ec_ractor_hooks(ec);
7678 rb_event_flag_t bmethod_events = ractor_events | bmethod_local_events;
7681 VALUE path = rb_iseq_path(iseq);
7682 VALUE label = rb_iseq_label(iseq);
7683 ruby_debug_printf(
"vm_trace>>%4d (%4x) - %.*s:%d %.*s\n",
7687 (
int)rb_iseq_line_no(iseq, pos),
7690 VM_ASSERT(reg_cfp->pc == pc);
7691 VM_ASSERT(pc_events != 0);
7701 VM_TRACE_HOOK(RUBY_EVENT_COVERAGE_LINE,
Qundef);
7702 VM_TRACE_HOOK(RUBY_EVENT_COVERAGE_BRANCH,
Qundef);
7708 if (bmethod_hooks_cnt > 0) bmethod_local_hooks = rb_method_def_local_hooks(bmethod_def, r,
false);
7716#if VM_CHECK_MODE > 0
7717NORETURN( NOINLINE( COLDFUNC
7718void rb_vm_canary_is_found_dead(
enum ruby_vminsn_type i,
VALUE c)));
7721Init_vm_stack_canary(
void)
7724 int n = ruby_fill_random_bytes(&vm_stack_canary,
sizeof vm_stack_canary,
false);
7727 vm_stack_canary >>= 2;
7729 vm_stack_canary |= 0x01;
7731 vm_stack_canary_was_born =
true;
7736rb_vm_canary_is_found_dead(
enum ruby_vminsn_type i,
VALUE c)
7740 const char *insn = rb_insns_name(i);
7744 rb_bug(
"dead canary found at %s: %s", insn, str);
7748void Init_vm_stack_canary(
void) { }
7777builtin_invoker0(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7779 typedef VALUE (*rb_invoke_funcptr0_t)(rb_execution_context_t *ec,
VALUE self);
7780 return (*(rb_invoke_funcptr0_t)funcptr)(ec, self);
7784builtin_invoker1(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7786 typedef VALUE (*rb_invoke_funcptr1_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1);
7787 return (*(rb_invoke_funcptr1_t)funcptr)(ec, self, argv[0]);
7791builtin_invoker2(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7793 typedef VALUE (*rb_invoke_funcptr2_t)(rb_execution_context_t *ec,
VALUE self,
VALUE v1,
VALUE v2);
7794 return (*(rb_invoke_funcptr2_t)funcptr)(ec, self, argv[0], argv[1]);
7798builtin_invoker3(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7801 return (*(rb_invoke_funcptr3_t)funcptr)(ec, self, argv[0], argv[1], argv[2]);
7805builtin_invoker4(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7808 return (*(rb_invoke_funcptr4_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3]);
7812builtin_invoker5(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7815 return (*(rb_invoke_funcptr5_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4]);
7819builtin_invoker6(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7822 return (*(rb_invoke_funcptr6_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
7826builtin_invoker7(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7829 return (*(rb_invoke_funcptr7_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
7833builtin_invoker8(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7836 return (*(rb_invoke_funcptr8_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
7840builtin_invoker9(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7842 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);
7843 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]);
7847builtin_invoker10(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7849 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);
7850 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]);
7854builtin_invoker11(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7856 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);
7857 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]);
7861builtin_invoker12(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7863 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);
7864 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]);
7868builtin_invoker13(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7870 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);
7871 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]);
7875builtin_invoker14(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7877 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);
7878 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]);
7882builtin_invoker15(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr)
7884 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);
7885 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]);
7888typedef VALUE (*builtin_invoker)(rb_execution_context_t *ec,
VALUE self,
const VALUE *argv, rb_insn_func_t funcptr);
7890static builtin_invoker
7891lookup_builtin_invoker(
int argc)
7893 static const builtin_invoker invokers[] = {
7912 return invokers[argc];
7916invoke_bf(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
const struct rb_builtin_function* bf,
const VALUE *argv)
7918 const bool canary_p = ISEQ_BODY(CFP_ISEQ(reg_cfp))->builtin_attrs & BUILTIN_ATTR_LEAF;
7919 SETUP_CANARY(canary_p);
7920 rb_insn_func_t func_ptr = (rb_insn_func_t)(uintptr_t)bf->func_ptr;
7921 VALUE ret = (*lookup_builtin_invoker(bf->argc))(ec, reg_cfp->self, argv, func_ptr);
7922 CHECK_CANARY(canary_p, BIN(invokebuiltin));
7927vm_invoke_builtin(rb_execution_context_t *ec, rb_control_frame_t *cfp,
const struct rb_builtin_function* bf,
const VALUE *argv)
7929 return invoke_bf(ec, cfp, bf, argv);
7933vm_invoke_builtin_delegate(rb_execution_context_t *ec, rb_control_frame_t *cfp,
const struct rb_builtin_function *bf,
unsigned int start_index)
7936 fputs(
"vm_invoke_builtin_delegate: passing -> ", stderr);
7937 for (
int i=0; i<bf->argc; i++) {
7938 ruby_debug_printf(
":%s ", rb_id2name(ISEQ_BODY(CFP_ISEQ(cfp))->local_table[i+start_index]));
7940 ruby_debug_printf(
"\n" "%s %s(%d):%p\n", RUBY_FUNCTION_NAME_STRING, bf->name, bf->argc,
7941 (
void *)(uintptr_t)bf->func_ptr);
7944 if (bf->argc == 0) {
7945 return invoke_bf(ec, cfp, bf, NULL);
7948 const VALUE *argv = cfp->ep - ISEQ_BODY(CFP_ISEQ(cfp))->local_table_size - VM_ENV_DATA_SIZE + 1 + start_index;
7949 return invoke_bf(ec, cfp, bf, argv);
7956rb_vm_lvar_exposed(rb_execution_context_t *ec,
int index)
7958 const rb_control_frame_t *cfp = ec->cfp;
7959 return cfp->ep[index];
#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.
static VALUE RB_FL_TEST_RAW(VALUE obj, VALUE flags)
This is an implementation detail of RB_FL_TEST().
static bool RB_FL_ABLE(VALUE obj)
Checks if the object is flaggable.
@ RUBY_FL_SHAREABLE
This flag has something to do with Ractor.
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 LEN2NUM
Old name of RB_LEN2NUM.
#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 UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define SYM2ID
Old name of RB_SYM2ID.
#define CLASS_OF
Old name of rb_class_of.
#define T_NONE
Old name of RUBY_T_NONE.
#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 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 rb_ary_new3
Old name of rb_ary_new_from_args.
#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_exc_raise(VALUE mesg)
Raises an exception in the current thread.
#define rb_notimplement()
#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.
@ 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_cObject
Object 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)
Same as RB_OBJ_FROZEN(), but returns Qtrue/Qfalse instead of bool.
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.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
int rb_during_gc(void)
Queries if the GC is busy.
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_entry(VALUE ary, rb_len_t off)
Queries an element of an array.
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.
void rb_ary_store(VALUE ary, rb_len_t key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
VALUE rb_ary_plus(VALUE lhs, VALUE rhs)
Creates a new array, concatenating the former to the latter.
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(rb_len_t 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_cat(VALUE ary, const VALUE *train, rb_len_t len)
Destructively appends multiple elements at the end of the array.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
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.
bool rb_set_lookup(VALUE set, VALUE element)
Whether the set contains the given element.
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.
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.
int rb_const_defined(VALUE space, ID name)
Queries if the constant is defined at the namespace.
int rb_method_basic_definition_p(VALUE klass, ID mid)
Well... Let us hesitate from describing what a "basic definition" is.
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.
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).
int off
Offset inside of ptr.
int len
Length of the buffer.
#define RB_OBJ_SET_SHAREABLE(obj)
Wrapper of rb_obj_set_shareable().
static bool rb_ractor_shareable_p(VALUE obj)
Queries if multiple Ractors can share the passed object or not.
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
#define RB_NOGVL_UBF_ASYNC_SAFE
Passing this flag to rb_nogvl() indicates that the passed UBF is async-signal-safe.
#define RB_NOGVL_INTR_FAIL
Passing this flag to rb_nogvl() prevents it from processing interrupts after the given function retur...
void * rb_nogvl(void *(*func)(void *), void *data1, rb_unblock_function_t *ubf, void *data2, int flags)
Identical to rb_thread_call_without_gvl(), except it additionally takes "flags" that change the behav...
#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.
static int RARRAY_LENINT(VALUE ary)
Identical to rb_array_len(), except it differs for the return type.
static VALUE * RARRAY_PTR(VALUE ary)
Wild use of a C pointer.
#define RARRAY_AREF(a, i)
References an object in an array.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
#define RBASIC(obj)
Convenient casting macro.
#define 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.
static int RSTRING_LENINT(VALUE str)
Identical to RSTRING_LEN(), except it differs for the return type.
#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 must be a hash of keywords.
#define RB_NO_KEYWORDS
Do not pass keywords.
static bool RB_SPECIAL_CONST_P(VALUE obj)
Checks if the given object is of enum ruby_special_consts.
#define RTEST
This is an old name of RB_TEST.
#define ANYARGS
Functions declared using this macro take arbitrary arguments, including void.
const VALUE ary[1]
Embedded elements.
const ID * segments
A null-terminated list of ids, used to represent a constant's path idNULL is used to represent the ::...
Internal header for Class.
rb_cref_t * cref
class reference, should be marked
const rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
IFUNC (Internal FUNCtion).
const VALUE cref_or_me
class reference or rb_method_entry_t
void rb_native_mutex_lock(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_lock.
void rb_native_cond_broadcast(rb_nativethread_cond_t *cond)
Signals a condition variable.
void rb_native_mutex_unlock(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_unlock.
void rb_native_cond_wait(rb_nativethread_cond_t *cond, rb_nativethread_lock_t *mutex)
Waits for the passed condition variable to be signalled.
long rb_len_t
A signed integer type for lengths and indices of objects such as String and Array.
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.
static enum ruby_value_type RB_BUILTIN_TYPE(VALUE obj)
Queries the type of the object.
static bool RB_FLOAT_TYPE_P(VALUE obj)
Queries if the object is an instance of rb_cFloat.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.