Ruby 4.0.10p0 (2026-11-19 revision a704b7cd95a42cc0cf5f307137bf3aac0285b915)
vm_insnhelper.c
1/**********************************************************************
2
3 vm_insnhelper.c - instruction helper functions. Included into vm.c.
4
5 $Author$
6
7 Copyright (C) 2007 Koichi Sasada
8
9**********************************************************************/
10
11#include "ruby/internal/config.h"
12
13#include <math.h>
14
15#ifdef HAVE_STDATOMIC_H
16 #include <stdatomic.h>
17#endif
18
19#include "constant.h"
20#include "debug_counter.h"
21#include "internal.h"
22#include "internal/class.h"
23#include "internal/compar.h"
24#include "internal/hash.h"
25#include "internal/numeric.h"
26#include "internal/proc.h"
27#include "internal/random.h"
28#include "internal/variable.h"
29#include "internal/set_table.h"
30#include "internal/struct.h"
31#include "variable.h"
32
33/* finish iseq array */
34#include "insns.inc"
35#include "insns_info.inc"
36
37extern rb_method_definition_t *rb_method_definition_create(rb_method_type_t type, ID mid);
38extern void rb_method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *def, void *opts);
39extern int rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2);
40extern VALUE rb_make_no_method_exception(VALUE exc, VALUE format, VALUE obj,
41 int argc, const VALUE *argv, int priv);
42
43static const struct rb_callcache vm_empty_cc;
44static const struct rb_callcache vm_empty_cc_for_super;
45
46/* control stack frame */
47
48static rb_control_frame_t *vm_get_ruby_level_caller_cfp(const rb_execution_context_t *ec, const rb_control_frame_t *cfp);
49
51ruby_vm_special_exception_copy(VALUE exc)
52{
53 VALUE e = rb_obj_alloc(rb_class_real(RBASIC_CLASS(exc)));
54 rb_obj_copy_ivar(e, exc);
55 return e;
56}
57
58NORETURN(static void ec_stack_overflow(rb_execution_context_t *ec, int));
59static void
60ec_stack_overflow(rb_execution_context_t *ec, int setup)
61{
62 VALUE mesg = rb_ec_vm_ptr(ec)->special_exceptions[ruby_error_sysstack];
63 ec->raised_flag = RAISED_STACKOVERFLOW;
64 if (setup) {
65 VALUE at = rb_ec_backtrace_object(ec);
66 mesg = ruby_vm_special_exception_copy(mesg);
67 rb_ivar_set(mesg, idBt, at);
68 rb_ivar_set(mesg, idBt_locations, at);
69 }
70 ec->errinfo = mesg;
71 EC_JUMP_TAG(ec, TAG_RAISE);
72}
73
74NORETURN(static void vm_stackoverflow(void));
75
76static void
77vm_stackoverflow(void)
78{
79 ec_stack_overflow(GET_EC(), TRUE);
80}
81
82void
83rb_ec_stack_overflow(rb_execution_context_t *ec, ruby_stack_overflow_critical_level crit)
84{
85 if (rb_during_gc()) {
86 rb_bug("system stack overflow during GC. Faulty native extension?");
87 }
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);
92 }
93 ec_stack_overflow(ec, crit < rb_stack_overflow_signal);
94}
95
96static inline void stack_check(rb_execution_context_t *ec);
97
98#if VM_CHECK_MODE > 0
99static int
100callable_class_p(VALUE klass)
101{
102#if VM_CHECK_MODE >= 2
103 if (!klass) return FALSE;
104 switch (RB_BUILTIN_TYPE(klass)) {
105 default:
106 break;
107 case T_ICLASS:
108 if (!RB_TYPE_P(RCLASS_SUPER(klass), T_MODULE)) break;
109 case T_MODULE:
110 return TRUE;
111 }
112 while (klass) {
113 if (klass == rb_cBasicObject) {
114 return TRUE;
115 }
116 klass = RCLASS_SUPER(klass);
117 }
118 return FALSE;
119#else
120 return klass != 0;
121#endif
122}
123
124static int
125callable_method_entry_p(const rb_callable_method_entry_t *cme)
126{
127 if (cme == NULL) {
128 return TRUE;
129 }
130 else {
131 VM_ASSERT(IMEMO_TYPE_P((VALUE)cme, imemo_ment), "imemo_type:%s", rb_imemo_name(imemo_type((VALUE)cme)));
132
133 if (callable_class_p(cme->defined_class)) {
134 return TRUE;
135 }
136 else {
137 return FALSE;
138 }
139 }
140}
141
142static void
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)
144{
145 unsigned int magic = (unsigned int)(type & VM_FRAME_MAGIC_MASK);
146 enum imemo_type cref_or_me_type = imemo_env; /* impossible value */
147
148 if (RB_TYPE_P(cref_or_me, T_IMEMO)) {
149 cref_or_me_type = imemo_type(cref_or_me);
150 }
151 if (type & VM_FRAME_FLAG_BMETHOD) {
152 req_me = TRUE;
153 }
154
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);
157 }
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);
160 }
161
162 if (req_me) {
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);
165 }
166 }
167 else {
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);
170 }
171 else { /* cref or Qfalse */
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)) {
174 /* ignore */
175 }
176 else {
177 rb_bug("vm_push_frame: (%s) should be false or cref on %x frame", rb_obj_info(cref_or_me), magic);
178 }
179 }
180 }
181 }
182
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;
185
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);
188 }
189 }
190
191 if ((type & VM_FRAME_MAGIC_MASK) == VM_FRAME_MAGIC_DUMMY) {
192 VM_ASSERT(iseq == NULL ||
193 RBASIC_CLASS((VALUE)iseq) == 0 || // dummy frame for loading
194 RUBY_VM_NORMAL_ISEQ_P(iseq) //argument error
195 );
196 }
197 else {
198 VM_ASSERT(is_cframe == !RUBY_VM_NORMAL_ISEQ_P(iseq));
199 }
200}
201
202static void
203vm_check_frame(VALUE type,
204 VALUE specval,
205 VALUE cref_or_me,
206 const rb_iseq_t *iseq)
207{
208 VALUE given_magic = type & VM_FRAME_MAGIC_MASK;
209 VM_ASSERT(FIXNUM_P(type));
210
211#define CHECK(magic, req_block, req_me, req_cref, is_cframe) \
212 case magic: \
213 vm_check_frame_detail(type, req_block, req_me, req_cref, \
214 specval, cref_or_me, is_cframe, iseq); \
215 break
216 switch (given_magic) {
217 /* BLK ME CREF CFRAME */
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);
227 default:
228 rb_bug("vm_push_frame: unknown type (%x)", (unsigned int)given_magic);
229 }
230#undef CHECK
231}
232
233static VALUE vm_stack_canary; /* Initialized later */
234static bool vm_stack_canary_was_born = false;
235
236// Return the index of the instruction right before the given PC.
237// This is needed because insn_entry advances PC before the insn body.
238static unsigned int
239previous_insn_index(const rb_iseq_t *iseq, const VALUE *pc)
240{
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) {
246 return pos;
247 }
248 pos = next_pos;
249 }
250 rb_bug("failed to find the previous insn");
251}
252
253void
254rb_vm_check_canary(const rb_execution_context_t *ec, VALUE *sp)
255{
256 const struct rb_control_frame_struct *reg_cfp = ec->cfp;
257 const struct rb_iseq_struct *iseq;
258
259 if (! LIKELY(vm_stack_canary_was_born)) {
260 return; /* :FIXME: isn't it rather fatal to enter this branch? */
261 }
262 else if ((VALUE *)reg_cfp == ec->vm_stack + ec->vm_stack_size) {
263 /* This is at the very beginning of a thread. cfp does not exist. */
264 return;
265 }
266 else if (! (iseq = GET_ISEQ())) {
267 return;
268 }
269 else if (LIKELY(sp[0] != vm_stack_canary)) {
270 return;
271 }
272 else {
273 /* we are going to call methods below; squash the canary to
274 * prevent infinite loop. */
275 sp[0] = Qundef;
276 }
277
278 const VALUE *orig = rb_iseq_original_iseq(iseq);
279 const VALUE iseqw = rb_iseqw_new(iseq);
280 const VALUE inspection = rb_inspect(iseqw);
281 const char *stri = rb_str_to_cstr(inspection);
282 const VALUE disasm = rb_iseq_disasm(iseq);
283 const char *strd = rb_str_to_cstr(disasm);
284 const ptrdiff_t pos = previous_insn_index(iseq, GET_PC());
285 const enum ruby_vminsn_type insn = (enum ruby_vminsn_type)orig[pos];
286 const char *name = insn_name(insn);
287
288 /* rb_bug() is not capable of outputting this large contents. It
289 is designed to run form a SIGSEGV handler, which tends to be
290 very restricted. */
291 ruby_debug_printf(
292 "We are killing the stack canary set by %s, "
293 "at %s@pc=%"PRIdPTR"\n"
294 "watch out the C stack trace.\n"
295 "%s",
296 name, stri, pos, strd);
297 rb_bug("see above.");
298}
299#define vm_check_canary(ec, sp) rb_vm_check_canary(ec, sp)
300
301#else
302#define vm_check_canary(ec, sp)
303#define vm_check_frame(a, b, c, d)
304#endif /* VM_CHECK_MODE > 0 */
305
306#if USE_DEBUG_COUNTER
307static void
308vm_push_frame_debug_counter_inc(
309 const struct rb_execution_context_struct *ec,
310 const struct rb_control_frame_struct *reg_cfp,
311 VALUE type)
312{
313 const struct rb_control_frame_struct *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(reg_cfp);
314
315 RB_DEBUG_COUNTER_INC(frame_push);
316
317 if (RUBY_VM_END_CONTROL_FRAME(ec) != prev_cfp) {
318 const bool curr = VM_FRAME_RUBYFRAME_P(reg_cfp);
319 const bool prev = VM_FRAME_RUBYFRAME_P(prev_cfp);
320 if (prev) {
321 if (curr) {
322 RB_DEBUG_COUNTER_INC(frame_R2R);
323 }
324 else {
325 RB_DEBUG_COUNTER_INC(frame_R2C);
326 }
327 }
328 else {
329 if (curr) {
330 RB_DEBUG_COUNTER_INC(frame_C2R);
331 }
332 else {
333 RB_DEBUG_COUNTER_INC(frame_C2C);
334 }
335 }
336 }
337
338 switch (type & VM_FRAME_MAGIC_MASK) {
339 case VM_FRAME_MAGIC_METHOD: RB_DEBUG_COUNTER_INC(frame_push_method); return;
340 case VM_FRAME_MAGIC_BLOCK: RB_DEBUG_COUNTER_INC(frame_push_block); return;
341 case VM_FRAME_MAGIC_CLASS: RB_DEBUG_COUNTER_INC(frame_push_class); return;
342 case VM_FRAME_MAGIC_TOP: RB_DEBUG_COUNTER_INC(frame_push_top); return;
343 case VM_FRAME_MAGIC_CFUNC: RB_DEBUG_COUNTER_INC(frame_push_cfunc); return;
344 case VM_FRAME_MAGIC_IFUNC: RB_DEBUG_COUNTER_INC(frame_push_ifunc); return;
345 case VM_FRAME_MAGIC_EVAL: RB_DEBUG_COUNTER_INC(frame_push_eval); return;
346 case VM_FRAME_MAGIC_RESCUE: RB_DEBUG_COUNTER_INC(frame_push_rescue); return;
347 case VM_FRAME_MAGIC_DUMMY: RB_DEBUG_COUNTER_INC(frame_push_dummy); return;
348 }
349
350 rb_bug("unreachable");
351}
352#else
353#define vm_push_frame_debug_counter_inc(ec, cfp, t) /* void */
354#endif
355
356// Return a poison value to be set above the stack top to verify leafness.
357VALUE
358rb_vm_stack_canary(void)
359{
360#if VM_CHECK_MODE > 0
361 return vm_stack_canary;
362#else
363 return 0;
364#endif
365}
366
367STATIC_ASSERT(VM_ENV_DATA_INDEX_ME_CREF, VM_ENV_DATA_INDEX_ME_CREF == -2);
368STATIC_ASSERT(VM_ENV_DATA_INDEX_SPECVAL, VM_ENV_DATA_INDEX_SPECVAL == -1);
369STATIC_ASSERT(VM_ENV_DATA_INDEX_FLAGS, VM_ENV_DATA_INDEX_FLAGS == -0);
370
371static void
372vm_push_frame(rb_execution_context_t *ec,
373 const rb_iseq_t *iseq,
374 VALUE type,
375 VALUE self,
376 VALUE specval,
377 VALUE cref_or_me,
378 const VALUE *pc,
379 VALUE *sp,
380 int local_size,
381 int stack_max)
382{
383 rb_control_frame_t *const cfp = RUBY_VM_NEXT_CONTROL_FRAME(ec->cfp);
384
385 vm_check_frame(type, specval, cref_or_me, iseq);
386 VM_ASSERT(local_size >= 0);
387
388 /* check stack overflow */
389 CHECK_VM_STACK_OVERFLOW0(cfp, sp, local_size + stack_max);
390 vm_check_canary(ec, sp);
391
392 /* setup vm value stack */
393
394 /* initialize local variables */
395 for (int i=0; i < local_size; i++) {
396 *sp++ = Qnil;
397 }
398
399 /* setup ep with managing data */
400 *sp++ = cref_or_me; /* ep[-2] / Qnil or T_IMEMO(cref) or T_IMEMO(ment) */
401 *sp++ = specval /* ep[-1] / block handler or prev env ptr */;
402 *sp++ = type; /* ep[-0] / ENV_FLAGS */
403
404 /* setup new frame */
405 *cfp = (const struct rb_control_frame_struct) {
406 .pc = pc,
407 .sp = sp,
408 .iseq = iseq,
409 .self = self,
410 .ep = sp - 1,
411 .block_code = NULL,
412#if VM_DEBUG_BP_CHECK
413 .bp_check = sp,
414#endif
415 .jit_return = NULL,
416 };
417
418 /* Ensure the initialization of `*cfp` above never gets reordered with the update of `ec->cfp` below.
419 This is a no-op in all cases we've looked at (https://godbolt.org/z/3oxd1446K), but should guarantee it for all
420 future/untested compilers/platforms. */
421
422 #if defined HAVE_DECL_ATOMIC_SIGNAL_FENCE && HAVE_DECL_ATOMIC_SIGNAL_FENCE
423 atomic_signal_fence(memory_order_seq_cst);
424 #endif
425
426 ec->cfp = cfp;
427
428 if (VMDEBUG == 2) {
429 SDR();
430 }
431 vm_push_frame_debug_counter_inc(ec, cfp, type);
432}
433
434void
435rb_vm_pop_frame_no_int(rb_execution_context_t *ec)
436{
437 rb_control_frame_t *cfp = ec->cfp;
438
439 if (VMDEBUG == 2) SDR();
440
441 ec->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
442}
443
444/* return TRUE if the frame is finished */
445static inline int
446vm_pop_frame(rb_execution_context_t *ec, rb_control_frame_t *cfp, const VALUE *ep)
447{
448 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
449
450 if (VMDEBUG == 2) SDR();
451
452 RUBY_VM_CHECK_INTS(ec);
453 ec->cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
454
455 return flags & VM_FRAME_FLAG_FINISH;
456}
457
458void
459rb_vm_pop_frame(rb_execution_context_t *ec)
460{
461 vm_pop_frame(ec, ec->cfp, ec->cfp->ep);
462}
463
464// it pushes pseudo-frame with fname filename.
465VALUE
466rb_vm_push_frame_fname(rb_execution_context_t *ec, VALUE fname)
467{
468 rb_iseq_t *rb_iseq_alloc_with_dummy_path(VALUE fname);
469 rb_iseq_t *dmy_iseq = rb_iseq_alloc_with_dummy_path(fname);
470
471 vm_push_frame(ec,
472 dmy_iseq, //const rb_iseq_t *iseq,
473 VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL | VM_FRAME_FLAG_FINISH, // VALUE type,
474 ec->cfp->self, // VALUE self,
475 VM_BLOCK_HANDLER_NONE, // VALUE specval,
476 Qfalse, // VALUE cref_or_me,
477 NULL, // const VALUE *pc,
478 ec->cfp->sp, // VALUE *sp,
479 0, // int local_size,
480 0); // int stack_max
481
482 return (VALUE)dmy_iseq;
483}
484
485/* method dispatch */
486static inline VALUE
487rb_arity_error_new(int argc, int min, int max)
488{
489 VALUE err_mess = rb_sprintf("wrong number of arguments (given %d, expected %d", argc, min);
490 if (min == max) {
491 /* max is not needed */
492 }
493 else if (max == UNLIMITED_ARGUMENTS) {
494 rb_str_cat_cstr(err_mess, "+");
495 }
496 else {
497 rb_str_catf(err_mess, "..%d", max);
498 }
499 rb_str_cat_cstr(err_mess, ")");
500 return rb_exc_new3(rb_eArgError, err_mess);
501}
502
503void
504rb_error_arity(int argc, int min, int max)
505{
506 rb_exc_raise(rb_arity_error_new(argc, min, max));
507}
508
509/* lvar */
510
511NOINLINE(static void vm_env_write_slowpath(const VALUE *ep, int index, VALUE v));
512
513static void
514vm_env_write_slowpath(const VALUE *ep, int index, VALUE v)
515{
516 /* remember env value forcely */
517 rb_gc_writebarrier_remember(VM_ENV_ENVVAL(ep));
518 VM_FORCE_WRITE(&ep[index], v);
519 VM_ENV_FLAGS_UNSET(ep, VM_ENV_FLAG_WB_REQUIRED);
520 RB_DEBUG_COUNTER_INC(lvar_set_slowpath);
521}
522
523// YJIT assumes this function never runs GC
524static inline void
525vm_env_write(const VALUE *ep, int index, VALUE v)
526{
527 VALUE flags = ep[VM_ENV_DATA_INDEX_FLAGS];
528 if (LIKELY((flags & VM_ENV_FLAG_WB_REQUIRED) == 0)) {
529 VM_STACK_ENV_WRITE(ep, index, v);
530 }
531 else {
532 vm_env_write_slowpath(ep, index, v);
533 }
534}
535
536void
537rb_vm_env_write(const VALUE *ep, int index, VALUE v)
538{
539 vm_env_write(ep, index, v);
540}
541
542VALUE
543rb_vm_bh_to_procval(const rb_execution_context_t *ec, VALUE block_handler)
544{
545 if (block_handler == VM_BLOCK_HANDLER_NONE) {
546 return Qnil;
547 }
548 else {
549 switch (vm_block_handler_type(block_handler)) {
550 case block_handler_type_iseq:
551 case block_handler_type_ifunc:
552 return rb_vm_make_proc(ec, VM_BH_TO_CAPT_BLOCK(block_handler), rb_cProc);
553 case block_handler_type_symbol:
554 return rb_sym_to_proc(VM_BH_TO_SYMBOL(block_handler));
555 case block_handler_type_proc:
556 return VM_BH_TO_PROC(block_handler);
557 default:
558 VM_UNREACHABLE(rb_vm_bh_to_procval);
559 }
560 }
561}
562
563/* svar */
564
565#if VM_CHECK_MODE > 0
566static int
567vm_svar_valid_p(VALUE svar)
568{
569 if (RB_TYPE_P((VALUE)svar, T_IMEMO)) {
570 switch (imemo_type(svar)) {
571 case imemo_svar:
572 case imemo_cref:
573 case imemo_ment:
574 return TRUE;
575 default:
576 break;
577 }
578 }
579 rb_bug("vm_svar_valid_p: unknown type: %s", rb_obj_info(svar));
580 return FALSE;
581}
582#endif
583
584static inline struct vm_svar *
585lep_svar(const rb_execution_context_t *ec, const VALUE *lep)
586{
587 VALUE svar;
588
589 if (lep && (ec == NULL || ec->root_lep != lep)) {
590 svar = lep[VM_ENV_DATA_INDEX_ME_CREF];
591 }
592 else {
593 svar = ec->root_svar;
594 }
595
596 VM_ASSERT(svar == Qfalse || vm_svar_valid_p(svar));
597
598 return (struct vm_svar *)svar;
599}
600
601static inline void
602lep_svar_write(const rb_execution_context_t *ec, const VALUE *lep, const struct vm_svar *svar)
603{
604 VM_ASSERT(vm_svar_valid_p((VALUE)svar));
605
606 if (lep && (ec == NULL || ec->root_lep != lep)) {
607 vm_env_write(lep, VM_ENV_DATA_INDEX_ME_CREF, (VALUE)svar);
608 }
609 else {
610 RB_OBJ_WRITE(rb_ec_thread_ptr(ec)->self, &ec->root_svar, svar);
611 }
612}
613
614static VALUE
615lep_svar_get(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t key)
616{
617 const struct vm_svar *svar = lep_svar(ec, lep);
618
619 if ((VALUE)svar == Qfalse || imemo_type((VALUE)svar) != imemo_svar) return Qnil;
620
621 switch (key) {
622 case VM_SVAR_LASTLINE:
623 return svar->lastline;
624 case VM_SVAR_BACKREF:
625 return svar->backref;
626 default: {
627 const VALUE ary = svar->others;
628
629 if (NIL_P(ary)) {
630 return Qnil;
631 }
632 else {
633 return rb_ary_entry(ary, key - VM_SVAR_EXTRA_START);
634 }
635 }
636 }
637}
638
639static struct vm_svar *
640svar_new(VALUE obj)
641{
642 struct vm_svar *svar = IMEMO_NEW(struct vm_svar, imemo_svar, obj);
643 *((VALUE *)&svar->lastline) = Qnil;
644 *((VALUE *)&svar->backref) = Qnil;
645 *((VALUE *)&svar->others) = Qnil;
646
647 return svar;
648}
649
650static void
651lep_svar_set(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t key, VALUE val)
652{
653 struct vm_svar *svar = lep_svar(ec, lep);
654
655 if ((VALUE)svar == Qfalse || imemo_type((VALUE)svar) != imemo_svar) {
656 lep_svar_write(ec, lep, svar = svar_new((VALUE)svar));
657 }
658
659 switch (key) {
660 case VM_SVAR_LASTLINE:
661 RB_OBJ_WRITE(svar, &svar->lastline, val);
662 return;
663 case VM_SVAR_BACKREF:
664 RB_OBJ_WRITE(svar, &svar->backref, val);
665 return;
666 default: {
667 VALUE ary = svar->others;
668
669 if (NIL_P(ary)) {
670 RB_OBJ_WRITE(svar, &svar->others, ary = rb_ary_new());
671 }
672 rb_ary_store(ary, key - VM_SVAR_EXTRA_START, val);
673 }
674 }
675}
676
677static inline VALUE
678vm_getspecial(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t key, rb_num_t type)
679{
680 VALUE val;
681
682 if (type == 0) {
683 val = lep_svar_get(ec, lep, key);
684 }
685 else {
686 VALUE backref = lep_svar_get(ec, lep, VM_SVAR_BACKREF);
687
688 if (type & 0x01) {
689 switch (type >> 1) {
690 case '&':
691 val = rb_reg_last_match(backref);
692 break;
693 case '`':
694 val = rb_reg_match_pre(backref);
695 break;
696 case '\'':
697 val = rb_reg_match_post(backref);
698 break;
699 case '+':
700 val = rb_reg_match_last(backref);
701 break;
702 default:
703 rb_bug("unexpected back-ref");
704 }
705 }
706 else {
707 val = rb_reg_nth_match((int)(type >> 1), backref);
708 }
709 }
710 return val;
711}
712
713static inline VALUE
714vm_backref_defined(const rb_execution_context_t *ec, const VALUE *lep, rb_num_t type)
715{
716 VALUE backref = lep_svar_get(ec, lep, VM_SVAR_BACKREF);
717 int nth = 0;
718
719 if (type & 0x01) {
720 switch (type >> 1) {
721 case '&':
722 case '`':
723 case '\'':
724 break;
725 case '+':
726 return rb_reg_last_defined(backref);
727 default:
728 rb_bug("unexpected back-ref");
729 }
730 }
731 else {
732 nth = (int)(type >> 1);
733 }
734 return rb_reg_nth_defined(nth, backref);
735}
736
737PUREFUNC(static rb_callable_method_entry_t *check_method_entry(VALUE obj, int can_be_svar));
738static rb_callable_method_entry_t *
739check_method_entry(VALUE obj, int can_be_svar)
740{
741 if (obj == Qfalse) return NULL;
742
743#if VM_CHECK_MODE > 0
744 if (!RB_TYPE_P(obj, T_IMEMO)) rb_bug("check_method_entry: unknown type: %s", rb_obj_info(obj));
745#endif
746
747 switch (imemo_type(obj)) {
748 case imemo_ment:
749 return (rb_callable_method_entry_t *)obj;
750 case imemo_cref:
751 return NULL;
752 case imemo_svar:
753 if (can_be_svar) {
754 return check_method_entry(((struct vm_svar *)obj)->cref_or_me, FALSE);
755 }
756 default:
757#if VM_CHECK_MODE > 0
758 rb_bug("check_method_entry: svar should not be there:");
759#endif
760 return NULL;
761 }
762}
763
764static rb_callable_method_entry_t *
765env_method_entry_unchecked(VALUE obj, int can_be_svar)
766{
767 if (obj == Qfalse) return NULL;
768
769 switch (imemo_type(obj)) {
770 case imemo_ment:
771 return (rb_callable_method_entry_t *)obj;
772 case imemo_cref:
773 return NULL;
774 case imemo_svar:
775 if (can_be_svar) {
776 return env_method_entry_unchecked(((struct vm_svar *)obj)->cref_or_me, FALSE);
777 }
778 default:
779 return NULL;
780 }
781}
782
783const rb_callable_method_entry_t *
784rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
785{
786 const VALUE *ep = cfp->ep;
787 rb_callable_method_entry_t *me;
788
789 while (!VM_ENV_LOCAL_P(ep)) {
790 if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me;
791 ep = VM_ENV_PREV_EP(ep);
792 }
793
794 return check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
795}
796
797const rb_callable_method_entry_t *
798rb_vm_frame_method_entry_unchecked(const rb_control_frame_t *cfp)
799{
800 const VALUE *ep = cfp->ep;
801 rb_callable_method_entry_t *me;
802
803 while (!VM_ENV_LOCAL_P_UNCHECKED(ep)) {
804 if ((me = env_method_entry_unchecked(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me;
805 ep = VM_ENV_PREV_EP_UNCHECKED(ep);
806 }
807
808 return env_method_entry_unchecked(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
809}
810
811static const rb_iseq_t *
812method_entry_iseqptr(const rb_callable_method_entry_t *me)
813{
814 switch (me->def->type) {
815 case VM_METHOD_TYPE_ISEQ:
816 return me->def->body.iseq.iseqptr;
817 default:
818 return NULL;
819 }
820}
821
822static rb_cref_t *
823method_entry_cref(const rb_callable_method_entry_t *me)
824{
825 switch (me->def->type) {
826 case VM_METHOD_TYPE_ISEQ:
827 return me->def->body.iseq.cref;
828 default:
829 return NULL;
830 }
831}
832
833#if VM_CHECK_MODE == 0
834PUREFUNC(static rb_cref_t *check_cref(VALUE, int));
835#endif
836static rb_cref_t *
837check_cref(VALUE obj, int can_be_svar)
838{
839 if (obj == Qfalse) return NULL;
840
841#if VM_CHECK_MODE > 0
842 if (!RB_TYPE_P(obj, T_IMEMO)) rb_bug("check_cref: unknown type: %s", rb_obj_info(obj));
843#endif
844
845 switch (imemo_type(obj)) {
846 case imemo_ment:
847 return method_entry_cref((rb_callable_method_entry_t *)obj);
848 case imemo_cref:
849 return (rb_cref_t *)obj;
850 case imemo_svar:
851 if (can_be_svar) {
852 return check_cref(((struct vm_svar *)obj)->cref_or_me, FALSE);
853 }
854 default:
855#if VM_CHECK_MODE > 0
856 rb_bug("check_method_entry: svar should not be there:");
857#endif
858 return NULL;
859 }
860}
861
862static inline rb_cref_t *
863vm_env_cref(const VALUE *ep)
864{
865 rb_cref_t *cref;
866
867 while (!VM_ENV_LOCAL_P(ep)) {
868 if ((cref = check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return cref;
869 ep = VM_ENV_PREV_EP(ep);
870 }
871
872 return check_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
873}
874
875static int
876is_cref(const VALUE v, int can_be_svar)
877{
878 if (RB_TYPE_P(v, T_IMEMO)) {
879 switch (imemo_type(v)) {
880 case imemo_cref:
881 return TRUE;
882 case imemo_svar:
883 if (can_be_svar) return is_cref(((struct vm_svar *)v)->cref_or_me, FALSE);
884 default:
885 break;
886 }
887 }
888 return FALSE;
889}
890
891static int
892vm_env_cref_by_cref(const VALUE *ep)
893{
894 while (!VM_ENV_LOCAL_P(ep)) {
895 if (is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) return TRUE;
896 ep = VM_ENV_PREV_EP(ep);
897 }
898 return is_cref(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
899}
900
901static rb_cref_t *
902cref_replace_with_duplicated_cref_each_frame(const VALUE *vptr, int can_be_svar, VALUE parent)
903{
904 const VALUE v = *vptr;
905 rb_cref_t *cref, *new_cref;
906
907 if (RB_TYPE_P(v, T_IMEMO)) {
908 switch (imemo_type(v)) {
909 case imemo_cref:
910 cref = (rb_cref_t *)v;
911 new_cref = vm_cref_dup(cref);
912 if (parent) {
913 RB_OBJ_WRITE(parent, vptr, new_cref);
914 }
915 else {
916 VM_FORCE_WRITE(vptr, (VALUE)new_cref);
917 }
918 return (rb_cref_t *)new_cref;
919 case imemo_svar:
920 if (can_be_svar) {
921 return cref_replace_with_duplicated_cref_each_frame(&((struct vm_svar *)v)->cref_or_me, FALSE, v);
922 }
923 /* fall through */
924 case imemo_ment:
925 rb_bug("cref_replace_with_duplicated_cref_each_frame: unreachable");
926 default:
927 break;
928 }
929 }
930 return NULL;
931}
932
933static rb_cref_t *
934vm_cref_replace_with_duplicated_cref(const VALUE *ep)
935{
936 if (vm_env_cref_by_cref(ep)) {
937 rb_cref_t *cref;
938 VALUE envval;
939
940 while (!VM_ENV_LOCAL_P(ep)) {
941 envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) : Qfalse;
942 if ((cref = cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE, envval)) != NULL) {
943 return cref;
944 }
945 ep = VM_ENV_PREV_EP(ep);
946 }
947 envval = VM_ENV_ESCAPED_P(ep) ? VM_ENV_ENVVAL(ep) : Qfalse;
948 return cref_replace_with_duplicated_cref_each_frame(&ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE, envval);
949 }
950 else {
951 rb_bug("vm_cref_dup: unreachable");
952 }
953}
954
955static rb_cref_t *
956vm_get_cref(const VALUE *ep)
957{
958 rb_cref_t *cref = vm_env_cref(ep);
959
960 if (cref != NULL) {
961 return cref;
962 }
963 else {
964 rb_bug("vm_get_cref: unreachable");
965 }
966}
967
968rb_cref_t *
969rb_vm_get_cref(const VALUE *ep)
970{
971 return vm_get_cref(ep);
972}
973
974static rb_cref_t *
975vm_ec_cref(const rb_execution_context_t *ec)
976{
977 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
978
979 if (cfp == NULL) {
980 return NULL;
981 }
982 return vm_get_cref(cfp->ep);
983}
984
985static const rb_cref_t *
986vm_get_const_key_cref(const VALUE *ep)
987{
988 const rb_cref_t *cref = vm_get_cref(ep);
989 const rb_cref_t *key_cref = cref;
990
991 while (cref) {
992 if (RCLASS_SINGLETON_P(CREF_CLASS(cref)) ||
993 RCLASS_CLONED_P(CREF_CLASS(cref)) ) {
994 return key_cref;
995 }
996 cref = CREF_NEXT(cref);
997 }
998
999 /* does not include singleton class */
1000 return NULL;
1001}
1002
1003rb_cref_t *
1004rb_vm_rewrite_cref(rb_cref_t *cref, VALUE old_klass, VALUE new_klass)
1005{
1006 rb_cref_t *new_cref_head = NULL;
1007 rb_cref_t *new_cref_tail = NULL;
1008
1009 #define ADD_NEW_CREF(new_cref) \
1010 if (new_cref_tail) { \
1011 RB_OBJ_WRITE(new_cref_tail, &new_cref_tail->next, new_cref); \
1012 } \
1013 else { \
1014 new_cref_head = new_cref; \
1015 } \
1016 new_cref_tail = new_cref;
1017
1018 while (cref) {
1019 rb_cref_t *new_cref;
1020 if (CREF_CLASS(cref) == old_klass) {
1021 new_cref = vm_cref_new_use_prev(new_klass, METHOD_VISI_UNDEF, FALSE, cref, FALSE);
1022 ADD_NEW_CREF(new_cref);
1023 return new_cref_head;
1024 }
1025 new_cref = vm_cref_new_use_prev(CREF_CLASS(cref), METHOD_VISI_UNDEF, FALSE, cref, FALSE);
1026 cref = CREF_NEXT(cref);
1027 ADD_NEW_CREF(new_cref);
1028 }
1029
1030 #undef ADD_NEW_CREF
1031
1032 // Could we just reuse the original cref?
1033 return new_cref_head;
1034}
1035
1036static rb_cref_t *
1037vm_cref_push(const rb_execution_context_t *ec, VALUE klass, const VALUE *ep, int pushed_by_eval, int singleton)
1038{
1039 rb_cref_t *prev_cref = NULL;
1040
1041 if (ep) {
1042 prev_cref = vm_env_cref(ep);
1043 }
1044 else {
1045 rb_control_frame_t *cfp = vm_get_ruby_level_caller_cfp(ec, ec->cfp);
1046
1047 if (cfp) {
1048 prev_cref = vm_env_cref(cfp->ep);
1049 }
1050 }
1051
1052 return vm_cref_new(klass, METHOD_VISI_PUBLIC, FALSE, prev_cref, pushed_by_eval, singleton);
1053}
1054
1055static inline VALUE
1056vm_get_cbase(const VALUE *ep)
1057{
1058 const rb_cref_t *cref = vm_get_cref(ep);
1059
1060 return CREF_CLASS_FOR_DEFINITION(cref);
1061}
1062
1063static inline VALUE
1064vm_get_const_base(const VALUE *ep)
1065{
1066 const rb_cref_t *cref = vm_get_cref(ep);
1067
1068 while (cref) {
1069 if (!CREF_PUSHED_BY_EVAL(cref)) {
1070 return CREF_CLASS_FOR_DEFINITION(cref);
1071 }
1072 cref = CREF_NEXT(cref);
1073 }
1074
1075 return Qundef;
1076}
1077
1078static inline void
1079vm_check_if_namespace(VALUE klass)
1080{
1081 if (!RB_TYPE_P(klass, T_CLASS) && !RB_TYPE_P(klass, T_MODULE)) {
1082 rb_raise(rb_eTypeError, "%+"PRIsVALUE" is not a class/module", klass);
1083 }
1084}
1085
1086static inline void
1087vm_ensure_not_refinement_module(VALUE self)
1088{
1089 if (RB_TYPE_P(self, T_MODULE) && FL_TEST(self, RMODULE_IS_REFINEMENT)) {
1090 rb_warn("not defined at the refinement, but at the outer class/module");
1091 }
1092}
1093
1094static inline VALUE
1095vm_get_iclass(const rb_control_frame_t *cfp, VALUE klass)
1096{
1097 return klass;
1098}
1099
1100static inline VALUE
1101vm_get_ev_const(rb_execution_context_t *ec, VALUE orig_klass, ID id, bool allow_nil, int is_defined)
1102{
1103 void rb_const_warn_if_deprecated(const rb_const_entry_t *ce, VALUE klass, ID id);
1104 VALUE val;
1105
1106 if (NIL_P(orig_klass) && allow_nil) {
1107 /* in current lexical scope */
1108 const rb_cref_t *root_cref = vm_get_cref(ec->cfp->ep);
1109 const rb_cref_t *cref;
1110 VALUE klass = Qnil;
1111
1112 while (root_cref && CREF_PUSHED_BY_EVAL(root_cref)) {
1113 root_cref = CREF_NEXT(root_cref);
1114 }
1115 cref = root_cref;
1116 while (cref && CREF_NEXT(cref)) {
1117 if (CREF_PUSHED_BY_EVAL(cref)) {
1118 klass = Qnil;
1119 }
1120 else {
1121 klass = CREF_CLASS(cref);
1122 }
1123 cref = CREF_NEXT(cref);
1124
1125 if (!NIL_P(klass)) {
1126 VALUE av, am = 0;
1127 rb_const_entry_t *ce;
1128 search_continue:
1129 if ((ce = rb_const_lookup(klass, id))) {
1130 rb_const_warn_if_deprecated(ce, klass, id);
1131 val = ce->value;
1132 if (UNDEF_P(val)) {
1133 if (am == klass) break;
1134 am = klass;
1135 if (is_defined) return 1;
1136 if (rb_autoloading_value(klass, id, &av, NULL)) return av;
1137 rb_autoload_load(klass, id);
1138 goto search_continue;
1139 }
1140 else {
1141 if (is_defined) {
1142 return 1;
1143 }
1144 else {
1145 if (UNLIKELY(!rb_ractor_main_p())) {
1146 if (!rb_ractor_shareable_p(val)) {
1147 rb_raise(rb_eRactorIsolationError,
1148 "can not access non-shareable objects in constant %"PRIsVALUE"::%"PRIsVALUE" by non-main ractor.", rb_class_path(klass), rb_id2str(id));
1149 }
1150 }
1151 return val;
1152 }
1153 }
1154 }
1155 }
1156 }
1157
1158 /* search self */
1159 if (root_cref && !NIL_P(CREF_CLASS(root_cref))) {
1160 klass = vm_get_iclass(ec->cfp, CREF_CLASS(root_cref));
1161 }
1162 else {
1163 klass = CLASS_OF(ec->cfp->self);
1164 }
1165
1166 if (is_defined) {
1167 return rb_const_defined(klass, id);
1168 }
1169 else {
1170 return rb_const_get(klass, id);
1171 }
1172 }
1173 else {
1174 vm_check_if_namespace(orig_klass);
1175 if (is_defined) {
1176 return rb_public_const_defined_from(orig_klass, id);
1177 }
1178 else {
1179 return rb_public_const_get_from(orig_klass, id);
1180 }
1181 }
1182}
1183
1184VALUE
1185rb_vm_get_ev_const(rb_execution_context_t *ec, VALUE orig_klass, ID id, VALUE allow_nil)
1186{
1187 return vm_get_ev_const(ec, orig_klass, id, allow_nil == Qtrue, 0);
1188}
1189
1190static inline VALUE
1191vm_get_ev_const_chain(rb_execution_context_t *ec, const ID *segments)
1192{
1193 VALUE val = Qnil;
1194 int idx = 0;
1195 int allow_nil = TRUE;
1196 if (segments[0] == idNULL) {
1197 val = rb_cObject;
1198 idx++;
1199 allow_nil = FALSE;
1200 }
1201 while (segments[idx]) {
1202 ID id = segments[idx++];
1203 val = vm_get_ev_const(ec, val, id, allow_nil, 0);
1204 allow_nil = FALSE;
1205 }
1206 return val;
1207}
1208
1209
1210static inline VALUE
1211vm_get_cvar_base(const rb_cref_t *cref, const rb_control_frame_t *cfp, int top_level_raise)
1212{
1213 VALUE klass;
1214
1215 if (!cref) {
1216 rb_bug("vm_get_cvar_base: no cref");
1217 }
1218
1219 while (CREF_NEXT(cref) &&
1220 (NIL_P(CREF_CLASS(cref)) || RCLASS_SINGLETON_P(CREF_CLASS(cref)) ||
1221 CREF_PUSHED_BY_EVAL(cref) || CREF_SINGLETON(cref))) {
1222 cref = CREF_NEXT(cref);
1223 }
1224 if (top_level_raise && !CREF_NEXT(cref)) {
1225 rb_raise(rb_eRuntimeError, "class variable access from toplevel");
1226 }
1227
1228 klass = vm_get_iclass(cfp, CREF_CLASS(cref));
1229
1230 if (NIL_P(klass)) {
1231 rb_raise(rb_eTypeError, "no class variables available");
1232 }
1233 return klass;
1234}
1235
1236ALWAYS_INLINE(static void fill_ivar_cache(const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, int is_attr, attr_index_t index, shape_id_t shape_id));
1237static inline void
1238fill_ivar_cache(const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, int is_attr, attr_index_t index, shape_id_t shape_id)
1239{
1240 if (is_attr) {
1241 vm_cc_attr_index_set(cc, index, shape_id);
1242 }
1243 else {
1244 vm_ic_attr_index_set(iseq, ic, index, shape_id);
1245 }
1246}
1247
1248#define ractor_incidental_shareable_p(cond, val) \
1249 (!(cond) || rb_ractor_shareable_p(val))
1250#define ractor_object_incidental_shareable_p(obj, val) \
1251 ractor_incidental_shareable_p(rb_ractor_shareable_p(obj), val)
1252
1253ALWAYS_INLINE(static VALUE vm_getivar(VALUE, ID, const rb_iseq_t *, IVC, const struct rb_callcache *, int, VALUE));
1254static inline VALUE
1255vm_getivar(VALUE obj, ID id, const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, int is_attr, VALUE default_value)
1256{
1257 VALUE fields_obj;
1258#if OPT_IC_FOR_IVAR
1259 if (SPECIAL_CONST_P(obj)) {
1260 return default_value;
1261 }
1262
1263 switch (BUILTIN_TYPE(obj)) {
1264 case T_OBJECT:
1265 fields_obj = obj;
1266 break;
1267 case T_CLASS:
1268 case T_MODULE:
1269 {
1270 if (UNLIKELY(!rb_ractor_main_p())) {
1271 // For two reasons we can only use the fast path on the main
1272 // ractor.
1273 // First, only the main ractor is allowed to set ivars on classes
1274 // and modules. So we can skip locking.
1275 // Second, other ractors need to check the shareability of the
1276 // values returned from the class ivars.
1277
1278 if (default_value == Qundef) { // defined?
1279 return rb_ivar_defined(obj, id) ? Qtrue : Qundef;
1280 }
1281 else {
1282 goto general_path;
1283 }
1284 }
1285
1286 fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
1287 break;
1288 }
1289 default:
1290 fields_obj = rb_obj_fields(obj, id);
1291 }
1292
1293 if (!fields_obj) {
1294 return default_value;
1295 }
1296
1297 VALUE val = Qundef;
1298
1299 shape_id_t shape_id = RBASIC_SHAPE_ID_FOR_READ(fields_obj);
1300 VALUE *ivar_list = rb_imemo_fields_ptr(fields_obj);
1301
1302 shape_id_t cached_id;
1303 attr_index_t index;
1304
1305 if (is_attr) {
1306 vm_cc_atomic_shape_and_index(cc, &cached_id, &index);
1307 }
1308 else {
1309 vm_ic_atomic_shape_and_index(ic, &cached_id, &index);
1310 }
1311
1312 if (LIKELY(cached_id == shape_id)) {
1313 RUBY_ASSERT(!rb_shape_too_complex_p(cached_id));
1314
1315 if (index == ATTR_INDEX_NOT_SET) {
1316 return default_value;
1317 }
1318
1319 val = ivar_list[index];
1320#if USE_DEBUG_COUNTER
1321 RB_DEBUG_COUNTER_INC(ivar_get_ic_hit);
1322
1323 if (RB_TYPE_P(obj, T_OBJECT)) {
1324 RB_DEBUG_COUNTER_INC(ivar_get_obj_hit);
1325 }
1326#endif
1327 RUBY_ASSERT(!UNDEF_P(val));
1328 }
1329 else { // cache miss case
1330#if USE_DEBUG_COUNTER
1331 if (is_attr) {
1332 if (cached_id != INVALID_SHAPE_ID) {
1333 RB_DEBUG_COUNTER_INC(ivar_get_cc_miss_set);
1334 }
1335 else {
1336 RB_DEBUG_COUNTER_INC(ivar_get_cc_miss_unset);
1337 }
1338 }
1339 else {
1340 if (cached_id != INVALID_SHAPE_ID) {
1341 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss_set);
1342 }
1343 else {
1344 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss_unset);
1345 }
1346 }
1347 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss);
1348
1349 if (RB_TYPE_P(obj, T_OBJECT)) {
1350 RB_DEBUG_COUNTER_INC(ivar_get_obj_miss);
1351 }
1352#endif
1353
1354 if (UNLIKELY(rb_shape_too_complex_p(shape_id))) {
1355 st_table *table = (st_table *)ivar_list;
1356
1357 RUBY_ASSERT(table);
1358 RUBY_ASSERT(table == rb_imemo_fields_complex_tbl(fields_obj));
1359
1360 if (!st_lookup(table, id, &val)) {
1361 val = default_value;
1362 }
1363 }
1364 else {
1365 shape_id_t previous_cached_id = cached_id;
1366 if (rb_shape_get_iv_index_with_hint(shape_id, id, &index, &cached_id)) {
1367 // This fills in the cache with the shared cache object.
1368 // "ent" is the shared cache object
1369 if (cached_id != previous_cached_id) {
1370 fill_ivar_cache(iseq, ic, cc, is_attr, index, cached_id);
1371 }
1372
1373 if (index == ATTR_INDEX_NOT_SET) {
1374 val = default_value;
1375 }
1376 else {
1377 // We fetched the ivar list above
1378 val = ivar_list[index];
1379 RUBY_ASSERT(!UNDEF_P(val));
1380 }
1381 }
1382 else {
1383 if (is_attr) {
1384 vm_cc_attr_index_initialize(cc, shape_id);
1385 }
1386 else {
1387 vm_ic_attr_index_initialize(ic, shape_id);
1388 }
1389
1390 val = default_value;
1391 }
1392 }
1393 }
1394
1395 if (!UNDEF_P(default_value)) {
1396 RUBY_ASSERT(!UNDEF_P(val));
1397 }
1398
1399 return val;
1400
1401general_path:
1402#endif /* OPT_IC_FOR_IVAR */
1403 RB_DEBUG_COUNTER_INC(ivar_get_ic_miss);
1404
1405 if (is_attr) {
1406 return rb_attr_get(obj, id);
1407 }
1408 else {
1409 return rb_ivar_get(obj, id);
1410 }
1411}
1412
1413static void
1414populate_cache(attr_index_t index, shape_id_t next_shape_id, ID id, const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, bool is_attr)
1415{
1416 RUBY_ASSERT(!rb_shape_too_complex_p(next_shape_id));
1417
1418 // Cache population code
1419 if (is_attr) {
1420 vm_cc_attr_index_set(cc, index, next_shape_id);
1421 }
1422 else {
1423 vm_ic_attr_index_set(iseq, ic, index, next_shape_id);
1424 }
1425}
1426
1427ALWAYS_INLINE(static VALUE vm_setivar_slowpath(VALUE obj, ID id, VALUE val, const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, int is_attr));
1428NOINLINE(static VALUE vm_setivar_slowpath_ivar(VALUE obj, ID id, VALUE val, const rb_iseq_t *iseq, IVC ic));
1429NOINLINE(static VALUE vm_setivar_slowpath_attr(VALUE obj, ID id, VALUE val, const struct rb_callcache *cc));
1430
1431static VALUE
1432vm_setivar_slowpath(VALUE obj, ID id, VALUE val, const rb_iseq_t *iseq, IVC ic, const struct rb_callcache *cc, int is_attr)
1433{
1434#if OPT_IC_FOR_IVAR
1435 RB_DEBUG_COUNTER_INC(ivar_set_ic_miss);
1436
1437 rb_check_frozen(obj);
1438
1439 attr_index_t index = rb_ivar_set_index(obj, id, val);
1440 shape_id_t next_shape_id = RBASIC_SHAPE_ID(obj);
1441
1442 if (!rb_shape_too_complex_p(next_shape_id)) {
1443 populate_cache(index, next_shape_id, id, iseq, ic, cc, is_attr);
1444 }
1445
1446 RB_DEBUG_COUNTER_INC(ivar_set_obj_miss);
1447 return val;
1448#else
1449 return rb_ivar_set(obj, id, val);
1450#endif
1451}
1452
1453static VALUE
1454vm_setivar_slowpath_ivar(VALUE obj, ID id, VALUE val, const rb_iseq_t *iseq, IVC ic)
1455{
1456 return vm_setivar_slowpath(obj, id, val, iseq, ic, NULL, false);
1457}
1458
1459static VALUE
1460vm_setivar_slowpath_attr(VALUE obj, ID id, VALUE val, const struct rb_callcache *cc)
1461{
1462 return vm_setivar_slowpath(obj, id, val, NULL, NULL, cc, true);
1463}
1464
1465NOINLINE(static VALUE vm_setivar_class(VALUE obj, ID id, VALUE val, shape_id_t dest_shape_id, attr_index_t index));
1466static VALUE
1467vm_setivar_class(VALUE obj, ID id, VALUE val, shape_id_t dest_shape_id, attr_index_t index)
1468{
1469 if (UNLIKELY(!rb_ractor_main_p())) {
1470 return Qundef;
1471 }
1472
1473 VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
1474 if (UNLIKELY(!fields_obj)) {
1475 return Qundef;
1476 }
1477
1478 shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);
1479
1480 // Cache hit case
1481 if (shape_id == dest_shape_id) {
1482 RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);
1483 }
1484 else if (dest_shape_id != INVALID_SHAPE_ID) {
1485 if (RSHAPE_DIRECT_CHILD_P(shape_id, dest_shape_id) && RSHAPE_EDGE_NAME(dest_shape_id) == id && RSHAPE_CAPACITY(shape_id) == RSHAPE_CAPACITY(dest_shape_id)) {
1486 RUBY_ASSERT(index < RSHAPE_CAPACITY(dest_shape_id));
1487 }
1488 else {
1489 return Qundef;
1490 }
1491 }
1492 else {
1493 return Qundef;
1494 }
1495
1496 RB_OBJ_WRITE(fields_obj, &rb_imemo_fields_ptr(fields_obj)[index], val);
1497
1498 if (shape_id != dest_shape_id) {
1499 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1500 RBASIC_SET_SHAPE_ID(fields_obj, dest_shape_id);
1501 }
1502
1503 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1504
1505 return val;
1506}
1507
1508NOINLINE(static VALUE vm_setivar_default(VALUE obj, ID id, VALUE val, shape_id_t dest_shape_id, attr_index_t index));
1509static VALUE
1510vm_setivar_default(VALUE obj, ID id, VALUE val, shape_id_t dest_shape_id, attr_index_t index)
1511{
1512 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1513
1514 // Cache hit case
1515 if (shape_id == dest_shape_id) {
1516 RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);
1517 }
1518 else if (dest_shape_id != INVALID_SHAPE_ID) {
1519 if (RSHAPE_DIRECT_CHILD_P(shape_id, dest_shape_id) && RSHAPE_EDGE_NAME(dest_shape_id) == id && RSHAPE_CAPACITY(shape_id) == RSHAPE_CAPACITY(dest_shape_id)) {
1520 RUBY_ASSERT(index < RSHAPE_CAPACITY(dest_shape_id));
1521 }
1522 else {
1523 return Qundef;
1524 }
1525 }
1526 else {
1527 return Qundef;
1528 }
1529
1530 VALUE fields_obj = rb_obj_fields(obj, id);
1531 RUBY_ASSERT(fields_obj);
1532 RB_OBJ_WRITE(fields_obj, &rb_imemo_fields_ptr(fields_obj)[index], val);
1533
1534 if (shape_id != dest_shape_id) {
1535 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1536 RBASIC_SET_SHAPE_ID(fields_obj, dest_shape_id);
1537 }
1538
1539 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1540
1541 return val;
1542}
1543
1544static inline VALUE
1545vm_setivar(VALUE obj, ID id, VALUE val, shape_id_t dest_shape_id, attr_index_t index)
1546{
1547#if OPT_IC_FOR_IVAR
1548 switch (BUILTIN_TYPE(obj)) {
1549 case T_OBJECT:
1550 {
1551 VM_ASSERT(!rb_ractor_shareable_p(obj) || rb_obj_frozen_p(obj));
1552
1553 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1554 RUBY_ASSERT(dest_shape_id == INVALID_SHAPE_ID || !rb_shape_too_complex_p(dest_shape_id));
1555
1556 if (LIKELY(shape_id == dest_shape_id)) {
1557 RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);
1558 VM_ASSERT(!rb_ractor_shareable_p(obj));
1559 }
1560 else if (dest_shape_id != INVALID_SHAPE_ID) {
1561 if (RSHAPE_DIRECT_CHILD_P(shape_id, dest_shape_id) && RSHAPE_EDGE_NAME(dest_shape_id) == id && RSHAPE_CAPACITY(shape_id) == RSHAPE_CAPACITY(dest_shape_id)) {
1562 RUBY_ASSERT(dest_shape_id != INVALID_SHAPE_ID && shape_id != INVALID_SHAPE_ID);
1563
1564 RBASIC_SET_SHAPE_ID(obj, dest_shape_id);
1565
1566 RUBY_ASSERT(index < RSHAPE_CAPACITY(dest_shape_id));
1567 }
1568 else {
1569 break;
1570 }
1571 }
1572 else {
1573 break;
1574 }
1575
1576 VALUE *ptr = ROBJECT_FIELDS(obj);
1577
1578 RUBY_ASSERT(!rb_shape_obj_too_complex_p(obj));
1579 RB_OBJ_WRITE(obj, &ptr[index], val);
1580
1581 RB_DEBUG_COUNTER_INC(ivar_set_ic_hit);
1582 RB_DEBUG_COUNTER_INC(ivar_set_obj_hit);
1583 return val;
1584 }
1585 break;
1586 case T_CLASS:
1587 case T_MODULE:
1588 RB_DEBUG_COUNTER_INC(ivar_set_ic_miss_noobject);
1589 default:
1590 break;
1591 }
1592
1593 return Qundef;
1594#endif /* OPT_IC_FOR_IVAR */
1595}
1596
1597static VALUE
1598update_classvariable_cache(const rb_iseq_t *iseq, VALUE klass, ID id, const rb_cref_t * cref, ICVARC ic)
1599{
1600 VALUE defined_class = 0;
1601 VALUE cvar_value = rb_cvar_find(klass, id, &defined_class);
1602
1603 if (RB_TYPE_P(defined_class, T_ICLASS)) {
1604 defined_class = RBASIC(defined_class)->klass;
1605 }
1606
1607 VALUE rb_cvc_tbl = RCLASS_CVC_TBL(defined_class);
1608 if (!rb_cvc_tbl) {
1609 rb_bug("the cvc table should be set");
1610 }
1611
1612 VALUE ent_data;
1613 if (!rb_marked_id_table_lookup(rb_cvc_tbl, id, &ent_data)) {
1614 rb_bug("should have cvar cache entry");
1615 }
1616
1617 struct rb_cvar_class_tbl_entry *ent = (void *)ent_data;
1618
1619 ent->global_cvar_state = GET_GLOBAL_CVAR_STATE();
1620 RB_OBJ_WRITE((VALUE)ent, &ent->cref, cref);
1621 RB_OBJ_WRITE(iseq, &ic->entry, ent);
1622
1623 RUBY_ASSERT(BUILTIN_TYPE((VALUE)cref) == T_IMEMO && IMEMO_TYPE_P(cref, imemo_cref));
1624
1625 return cvar_value;
1626}
1627
1628static inline VALUE
1629vm_getclassvariable(const rb_iseq_t *iseq, const rb_control_frame_t *reg_cfp, ID id, ICVARC ic)
1630{
1631 const rb_cref_t *cref;
1632 cref = vm_get_cref(GET_EP());
1633
1634 if (ic->entry && ic->entry->global_cvar_state == GET_GLOBAL_CVAR_STATE() && ic->entry->cref == cref && LIKELY(rb_ractor_main_p())) {
1635 RB_DEBUG_COUNTER_INC(cvar_read_inline_hit);
1636
1637 VALUE v = rb_ivar_lookup(ic->entry->class_value, id, Qundef);
1638 RUBY_ASSERT(!UNDEF_P(v));
1639
1640 return v;
1641 }
1642
1643 VALUE klass = vm_get_cvar_base(cref, reg_cfp, 1);
1644
1645 return update_classvariable_cache(iseq, klass, id, cref, ic);
1646}
1647
1648VALUE
1649rb_vm_getclassvariable(const rb_iseq_t *iseq, const rb_control_frame_t *cfp, ID id, ICVARC ic)
1650{
1651 return vm_getclassvariable(iseq, cfp, id, ic);
1652}
1653
1654static inline void
1655vm_setclassvariable(const rb_iseq_t *iseq, const rb_control_frame_t *reg_cfp, ID id, VALUE val, ICVARC ic)
1656{
1657 const rb_cref_t *cref;
1658 cref = vm_get_cref(GET_EP());
1659
1660 if (ic->entry && ic->entry->global_cvar_state == GET_GLOBAL_CVAR_STATE() && ic->entry->cref == cref && LIKELY(rb_ractor_main_p())) {
1661 RB_DEBUG_COUNTER_INC(cvar_write_inline_hit);
1662
1663 rb_class_ivar_set(ic->entry->class_value, id, val);
1664 return;
1665 }
1666
1667 VALUE klass = vm_get_cvar_base(cref, reg_cfp, 1);
1668
1669 rb_cvar_set(klass, id, val);
1670
1671 update_classvariable_cache(iseq, klass, id, cref, ic);
1672}
1673
1674void
1675rb_vm_setclassvariable(const rb_iseq_t *iseq, const rb_control_frame_t *cfp, ID id, VALUE val, ICVARC ic)
1676{
1677 vm_setclassvariable(iseq, cfp, id, val, ic);
1678}
1679
1680ALWAYS_INLINE(static VALUE vm_getinstancevariable(const rb_iseq_t *iseq, VALUE obj, ID id, IVC ic));
1681static inline VALUE
1682vm_getinstancevariable(const rb_iseq_t *iseq, VALUE obj, ID id, IVC ic)
1683{
1684 return vm_getivar(obj, id, iseq, ic, NULL, FALSE, Qnil);
1685}
1686
1687static inline void
1688vm_setinstancevariable(const rb_iseq_t *iseq, VALUE obj, ID id, VALUE val, IVC ic)
1689{
1690 if (RB_SPECIAL_CONST_P(obj)) {
1692 return;
1693 }
1694
1695 shape_id_t dest_shape_id;
1696 attr_index_t index;
1697 vm_ic_atomic_shape_and_index(ic, &dest_shape_id, &index);
1698
1699 if (UNLIKELY(UNDEF_P(vm_setivar(obj, id, val, dest_shape_id, index)))) {
1700 switch (BUILTIN_TYPE(obj)) {
1701 case T_OBJECT:
1702 break;
1703 case T_CLASS:
1704 case T_MODULE:
1705 if (!UNDEF_P(vm_setivar_class(obj, id, val, dest_shape_id, index))) {
1706 return;
1707 }
1708 break;
1709 default:
1710 if (!UNDEF_P(vm_setivar_default(obj, id, val, dest_shape_id, index))) {
1711 return;
1712 }
1713 }
1714 vm_setivar_slowpath_ivar(obj, id, val, iseq, ic);
1715 }
1716}
1717
1718void
1719rb_vm_setinstancevariable(const rb_iseq_t *iseq, VALUE obj, ID id, VALUE val, IVC ic)
1720{
1721 vm_setinstancevariable(iseq, obj, id, val, ic);
1722}
1723
1724VALUE
1725rb_vm_getinstancevariable(const rb_iseq_t *iseq, VALUE obj, ID id, IVC ic)
1726{
1727 return vm_getinstancevariable(iseq, obj, id, ic);
1728}
1729
1730static VALUE
1731vm_throw_continue(const rb_execution_context_t *ec, VALUE err)
1732{
1733 /* continue throw */
1734
1735 if (FIXNUM_P(err)) {
1736 ec->tag->state = RUBY_TAG_FATAL;
1737 }
1738 else if (SYMBOL_P(err)) {
1739 ec->tag->state = TAG_THROW;
1740 }
1741 else if (THROW_DATA_P(err)) {
1742 ec->tag->state = THROW_DATA_STATE((struct vm_throw_data *)err);
1743 }
1744 else {
1745 ec->tag->state = TAG_RAISE;
1746 }
1747 return err;
1748}
1749
1750static VALUE
1751vm_throw_start(const rb_execution_context_t *ec, rb_control_frame_t *const reg_cfp, enum ruby_tag_type state,
1752 const int flag, const VALUE throwobj)
1753{
1754 const rb_control_frame_t *escape_cfp = NULL;
1755 const rb_control_frame_t * const eocfp = RUBY_VM_END_CONTROL_FRAME(ec); /* end of control frame pointer */
1756
1757 if (flag != 0) {
1758 /* do nothing */
1759 }
1760 else if (state == TAG_BREAK) {
1761 int is_orphan = 1;
1762 const VALUE *ep = GET_EP();
1763 const rb_iseq_t *base_iseq = GET_ISEQ();
1764 escape_cfp = reg_cfp;
1765
1766 while (ISEQ_BODY(base_iseq)->type != ISEQ_TYPE_BLOCK) {
1767 if (ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_CLASS) {
1768 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1769 ep = escape_cfp->ep;
1770 base_iseq = escape_cfp->iseq;
1771 }
1772 else {
1773 ep = VM_ENV_PREV_EP(ep);
1774 base_iseq = ISEQ_BODY(base_iseq)->parent_iseq;
1775 escape_cfp = rb_vm_search_cf_from_ep(ec, escape_cfp, ep);
1776 VM_ASSERT(escape_cfp->iseq == base_iseq);
1777 }
1778 }
1779
1780 if (VM_FRAME_LAMBDA_P(escape_cfp)) {
1781 /* lambda{... break ...} */
1782 is_orphan = 0;
1783 state = TAG_RETURN;
1784 }
1785 else {
1786 ep = VM_ENV_PREV_EP(ep);
1787
1788 while (escape_cfp < eocfp) {
1789 if (escape_cfp->ep == ep) {
1790 const rb_iseq_t *const iseq = escape_cfp->iseq;
1791 const VALUE epc = escape_cfp->pc - ISEQ_BODY(iseq)->iseq_encoded;
1792 const struct iseq_catch_table *const ct = ISEQ_BODY(iseq)->catch_table;
1793 unsigned int i;
1794
1795 if (!ct) break;
1796 for (i=0; i < ct->size; i++) {
1797 const struct iseq_catch_table_entry *const entry =
1798 UNALIGNED_MEMBER_PTR(ct, entries[i]);
1799
1800 if (entry->type == CATCH_TYPE_BREAK &&
1801 entry->iseq == base_iseq &&
1802 entry->start < epc && entry->end >= epc) {
1803 if (entry->cont == epc) { /* found! */
1804 is_orphan = 0;
1805 }
1806 break;
1807 }
1808 }
1809 break;
1810 }
1811
1812 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1813 }
1814 }
1815
1816 if (is_orphan) {
1817 rb_vm_localjump_error("break from proc-closure", throwobj, TAG_BREAK);
1818 }
1819 }
1820 else if (state == TAG_RETRY) {
1821 const VALUE *ep = VM_ENV_PREV_EP(GET_EP());
1822
1823 escape_cfp = rb_vm_search_cf_from_ep(ec, reg_cfp, ep);
1824 }
1825 else if (state == TAG_RETURN) {
1826 const VALUE *current_ep = GET_EP();
1827 const VALUE *target_ep = NULL, *target_lep, *ep = current_ep;
1828 int in_class_frame = 0;
1829 int toplevel = 1;
1830 escape_cfp = reg_cfp;
1831
1832 // find target_lep, target_ep
1833 while (!VM_ENV_LOCAL_P(ep)) {
1834 if (VM_ENV_FLAGS(ep, VM_FRAME_FLAG_LAMBDA) && target_ep == NULL) {
1835 target_ep = ep;
1836 }
1837 ep = VM_ENV_PREV_EP(ep);
1838 }
1839 target_lep = ep;
1840
1841 while (escape_cfp < eocfp) {
1842 const VALUE *lep = VM_CF_LEP(escape_cfp);
1843
1844 if (!target_lep) {
1845 target_lep = lep;
1846 }
1847
1848 if (lep == target_lep &&
1849 VM_FRAME_RUBYFRAME_P(escape_cfp) &&
1850 ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_CLASS) {
1851 in_class_frame = 1;
1852 target_lep = 0;
1853 }
1854
1855 if (lep == target_lep) {
1856 if (VM_FRAME_LAMBDA_P(escape_cfp)) {
1857 toplevel = 0;
1858 if (in_class_frame) {
1859 /* lambda {class A; ... return ...; end} */
1860 goto valid_return;
1861 }
1862 else {
1863 const VALUE *tep = current_ep;
1864
1865 while (target_lep != tep) {
1866 if (escape_cfp->ep == tep) {
1867 /* in lambda */
1868 if (tep == target_ep) {
1869 goto valid_return;
1870 }
1871 else {
1872 goto unexpected_return;
1873 }
1874 }
1875 tep = VM_ENV_PREV_EP(tep);
1876 }
1877 }
1878 }
1879 else if (VM_FRAME_RUBYFRAME_P(escape_cfp)) {
1880 switch (ISEQ_BODY(escape_cfp->iseq)->type) {
1881 case ISEQ_TYPE_TOP:
1882 case ISEQ_TYPE_MAIN:
1883 if (toplevel) {
1884 if (in_class_frame) goto unexpected_return;
1885 if (target_ep == NULL) {
1886 goto valid_return;
1887 }
1888 else {
1889 goto unexpected_return;
1890 }
1891 }
1892 break;
1893 case ISEQ_TYPE_EVAL: {
1894 const rb_iseq_t *is = escape_cfp->iseq;
1895 enum rb_iseq_type t = ISEQ_BODY(is)->type;
1896 while (t == ISEQ_TYPE_RESCUE || t == ISEQ_TYPE_ENSURE || t == ISEQ_TYPE_EVAL) {
1897 if (!(is = ISEQ_BODY(is)->parent_iseq)) break;
1898 t = ISEQ_BODY(is)->type;
1899 }
1900 toplevel = t == ISEQ_TYPE_TOP || t == ISEQ_TYPE_MAIN;
1901 break;
1902 }
1903 case ISEQ_TYPE_CLASS:
1904 toplevel = 0;
1905 break;
1906 default:
1907 break;
1908 }
1909 }
1910 }
1911
1912 if (escape_cfp->ep == target_lep && ISEQ_BODY(escape_cfp->iseq)->type == ISEQ_TYPE_METHOD) {
1913 if (target_ep == NULL) {
1914 goto valid_return;
1915 }
1916 else {
1917 goto unexpected_return;
1918 }
1919 }
1920
1921 escape_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(escape_cfp);
1922 }
1923 unexpected_return:;
1924 rb_vm_localjump_error("unexpected return", throwobj, TAG_RETURN);
1925
1926 valid_return:;
1927 /* do nothing */
1928 }
1929 else {
1930 rb_bug("isns(throw): unsupported throw type");
1931 }
1932
1933 ec->tag->state = state;
1934 return (VALUE)THROW_DATA_NEW(throwobj, escape_cfp, state);
1935}
1936
1937static VALUE
1938vm_throw(const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
1939 rb_num_t throw_state, VALUE throwobj)
1940{
1941 const int state = (int)(throw_state & VM_THROW_STATE_MASK);
1942 const int flag = (int)(throw_state & VM_THROW_NO_ESCAPE_FLAG);
1943
1944 if (state != 0) {
1945 return vm_throw_start(ec, reg_cfp, state, flag, throwobj);
1946 }
1947 else {
1948 return vm_throw_continue(ec, throwobj);
1949 }
1950}
1951
1952VALUE
1953rb_vm_throw(const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t throw_state, VALUE throwobj)
1954{
1955 return vm_throw(ec, reg_cfp, throw_state, throwobj);
1956}
1957
1958static inline void
1959vm_expandarray(struct rb_control_frame_struct *cfp, VALUE ary, rb_num_t num, int flag)
1960{
1961 int is_splat = flag & 0x01;
1962 const VALUE *ptr;
1963 rb_num_t len;
1964 const VALUE obj = ary;
1965
1966 if (!RB_TYPE_P(ary, T_ARRAY) && NIL_P(ary = rb_check_array_type(ary))) {
1967 ary = obj;
1968 ptr = &ary;
1969 len = 1;
1970 }
1971 else {
1972 ptr = RARRAY_CONST_PTR(ary);
1973 len = (rb_num_t)RARRAY_LEN(ary);
1974 }
1975
1976 if (num + is_splat == 0) {
1977 /* no space left on stack */
1978 }
1979 else if (flag & 0x02) {
1980 /* post: ..., nil ,ary[-1], ..., ary[0..-num] # top */
1981 rb_num_t i = 0, j;
1982
1983 if (len < num) {
1984 for (i = 0; i < num - len; i++) {
1985 *cfp->sp++ = Qnil;
1986 }
1987 }
1988
1989 for (j = 0; i < num; i++, j++) {
1990 VALUE v = ptr[len - j - 1];
1991 *cfp->sp++ = v;
1992 }
1993
1994 if (is_splat) {
1995 *cfp->sp++ = rb_ary_new4(len - j, ptr);
1996 }
1997 }
1998 else {
1999 /* normal: ary[num..-1], ary[num-2], ary[num-3], ..., ary[0] # top */
2000 if (is_splat) {
2001 if (num > len) {
2002 *cfp->sp++ = rb_ary_new();
2003 }
2004 else {
2005 *cfp->sp++ = rb_ary_new4(len - num, ptr + num);
2006 }
2007 }
2008
2009 if (num > len) {
2010 rb_num_t i = 0;
2011 for (; i < num - len; i++) {
2012 *cfp->sp++ = Qnil;
2013 }
2014
2015 for (rb_num_t j = 0; i < num; i++, j++) {
2016 *cfp->sp++ = ptr[len - j - 1];
2017 }
2018 }
2019 else {
2020 for (rb_num_t j = 0; j < num; j++) {
2021 *cfp->sp++ = ptr[num - j - 1];
2022 }
2023 }
2024 }
2025
2026 RB_GC_GUARD(ary);
2027}
2028
2029static VALUE vm_call_general(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling);
2030
2031static VALUE vm_mtbl_dump(VALUE klass, ID target_mid);
2032
2033static struct rb_class_cc_entries *
2034vm_ccs_create(VALUE klass, VALUE cc_tbl, ID mid, const rb_callable_method_entry_t *cme)
2035{
2036 int initial_capa = 2;
2037 struct rb_class_cc_entries *ccs = ruby_xmalloc(vm_ccs_alloc_size(initial_capa));
2038#if VM_CHECK_MODE > 0
2039 ccs->debug_sig = ~(VALUE)ccs;
2040#endif
2041 ccs->capa = initial_capa;
2042 ccs->len = 0;
2043 ccs->cme = cme;
2044 METHOD_ENTRY_CACHED_SET((rb_callable_method_entry_t *)cme);
2045
2046 rb_managed_id_table_insert(cc_tbl, mid, (VALUE)ccs);
2047 RB_OBJ_WRITTEN(cc_tbl, Qundef, cme);
2048 return ccs;
2049}
2050
2051static void
2052vm_ccs_push(VALUE cc_tbl, ID mid, struct rb_class_cc_entries *ccs, const struct rb_callinfo *ci, const struct rb_callcache *cc)
2053{
2054 if (! vm_cc_markable(cc)) {
2055 return;
2056 }
2057
2058 if (UNLIKELY(ccs->len == ccs->capa)) {
2059 RUBY_ASSERT(ccs->capa > 0);
2060 ccs->capa *= 2;
2061 ccs = ruby_xrealloc(ccs, vm_ccs_alloc_size(ccs->capa));
2062#if VM_CHECK_MODE > 0
2063 ccs->debug_sig = ~(VALUE)ccs;
2064#endif
2065 // GC?
2066 rb_managed_id_table_insert(cc_tbl, mid, (VALUE)ccs);
2067 }
2068 VM_ASSERT(ccs->len < ccs->capa);
2069
2070 const struct rb_callinfo_kwarg *kwarg = vm_ci_kwarg(ci);
2071 const int pos = ccs->len++;
2072 ccs->entries[pos].argc = vm_ci_argc(ci);
2073 ccs->entries[pos].flag = (unsigned short)vm_ci_flag(ci);
2074 ccs->entries[pos].kw_len = (unsigned short)(kwarg ? kwarg->keyword_len : 0);
2075 RB_OBJ_WRITE(cc_tbl, &ccs->entries[pos].cc, cc);
2076
2077 if (RB_DEBUG_COUNTER_SETMAX(ccs_maxlen, ccs->len)) {
2078 // for tuning
2079 // vm_mtbl_dump(klass, 0);
2080 }
2081}
2082
2083#if VM_CHECK_MODE > 0
2084void
2085rb_vm_ccs_dump(struct rb_class_cc_entries *ccs)
2086{
2087 ruby_debug_printf("ccs:%p (%d,%d)\n", (void *)ccs, ccs->len, ccs->capa);
2088 for (int i=0; i<ccs->len; i++) {
2089 ruby_debug_printf("CCS CI ID:flag:%x argc:%u kw_len:%u\n",
2090 ccs->entries[i].flag,
2091 ccs->entries[i].argc,
2092 ccs->entries[i].kw_len);
2093 rp(ccs->entries[i].cc);
2094 }
2095}
2096
2097static int
2098vm_ccs_verify(struct rb_class_cc_entries *ccs, ID mid, VALUE klass)
2099{
2100 VM_ASSERT(vm_ccs_p(ccs));
2101 VM_ASSERT(ccs->len <= ccs->capa);
2102
2103 for (int i=0; i<ccs->len; i++) {
2104 const struct rb_callcache *cc = ccs->entries[i].cc;
2105
2106 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
2107 VM_ASSERT(vm_cc_class_check(cc, klass));
2108 VM_ASSERT(vm_cc_check_cme(cc, ccs->cme));
2109 VM_ASSERT(!vm_cc_super_p(cc));
2110 VM_ASSERT(!vm_cc_refinement_p(cc));
2111 }
2112 return TRUE;
2113}
2114#endif
2115
2116const rb_callable_method_entry_t *rb_check_overloaded_cme(const rb_callable_method_entry_t *cme, const struct rb_callinfo * const ci);
2117
2118static void
2119vm_evict_cc(VALUE klass, VALUE cc_tbl, ID mid)
2120{
2121 ASSERT_vm_locking();
2122
2123 if (rb_multi_ractor_p()) {
2124 if (RCLASS_WRITABLE_CC_TBL(klass) != cc_tbl) {
2125 // Another ractor updated the CC table while we were waiting on the VM lock.
2126 // We have to retry.
2127 return;
2128 }
2129
2130 VALUE ccs_obj = 0;
2131 rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj);
2132 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_obj;
2133
2134 if (!ccs || !METHOD_ENTRY_INVALIDATED(ccs->cme)) {
2135 // Another ractor replaced that entry while we were waiting on the VM lock.
2136 return;
2137 }
2138
2139 VALUE new_table = rb_vm_cc_table_dup(cc_tbl);
2140 rb_vm_cc_table_delete(new_table, mid);
2141 RB_OBJ_ATOMIC_WRITE(klass, &RCLASS_WRITABLE_CC_TBL(klass), new_table);
2142 }
2143 else {
2144 rb_vm_cc_table_delete(cc_tbl, mid);
2145 }
2146}
2147
2148static const struct rb_callcache *
2149vm_populate_cc(VALUE klass, const struct rb_callinfo * const ci, ID mid)
2150{
2151 ASSERT_vm_locking();
2152
2153 RB_DEBUG_COUNTER_INC(cc_not_found_in_ccs);
2154
2155 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, mid);
2156
2157 VM_ASSERT(cme == NULL || IMEMO_TYPE_P(cme, imemo_ment));
2158
2159 if (cme == NULL) {
2160 // undef or not found: can't cache the information
2161 VM_ASSERT(vm_cc_cme(&vm_empty_cc) == NULL);
2162 return &vm_empty_cc;
2163 }
2164
2165 VALUE cc_tbl = RCLASS_WRITABLE_CC_TBL(klass);
2166 const VALUE original_cc_table = cc_tbl;
2167 if (!cc_tbl) {
2168 // Is this possible after rb_callable_method_entry ?
2169 cc_tbl = rb_vm_cc_table_create(1);
2170 }
2171 else if (rb_multi_ractor_p()) {
2172 cc_tbl = rb_vm_cc_table_dup(cc_tbl);
2173 }
2174
2175 VM_ASSERT(cme == rb_callable_method_entry(klass, mid));
2176
2177 METHOD_ENTRY_CACHED_SET((struct rb_callable_method_entry_struct *)cme);
2178
2179 VM_ASSERT(cc_tbl);
2180
2181 struct rb_class_cc_entries *ccs = NULL;
2182 {
2183 VALUE ccs_obj;
2184 if (UNLIKELY(rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj))) {
2185 ccs = (struct rb_class_cc_entries *)ccs_obj;
2186 }
2187 else {
2188 // TODO: required?
2189 ccs = vm_ccs_create(klass, cc_tbl, mid, cme);
2190 }
2191 }
2192
2193 cme = rb_check_overloaded_cme(cme, ci);
2194
2195 const struct rb_callcache *cc = vm_cc_new(klass, cme, vm_call_general, cc_type_normal);
2196 vm_ccs_push(cc_tbl, mid, ccs, ci, cc);
2197
2198 VM_ASSERT(vm_cc_cme(cc) != NULL);
2199 VM_ASSERT(cme->called_id == mid);
2200 VM_ASSERT(vm_cc_cme(cc)->called_id == mid);
2201
2202 if (original_cc_table != cc_tbl) {
2203 RB_OBJ_ATOMIC_WRITE(klass, &RCLASS_WRITABLE_CC_TBL(klass), cc_tbl);
2204 }
2205
2206 return cc;
2207}
2208
2209static const struct rb_callcache *
2210vm_lookup_cc(const VALUE klass, const struct rb_callinfo * const ci, ID mid)
2211{
2212 VALUE cc_tbl;
2213 struct rb_class_cc_entries *ccs;
2214retry:
2215 cc_tbl = RUBY_ATOMIC_VALUE_LOAD(RCLASS_WRITABLE_CC_TBL(klass));
2216 ccs = NULL;
2217
2218 if (cc_tbl) {
2219 // CCS data is keyed on method id, so we don't need the method id
2220 // for doing comparisons in the `for` loop below.
2221
2222 VALUE ccs_obj;
2223 if (rb_managed_id_table_lookup(cc_tbl, mid, &ccs_obj)) {
2224 ccs = (struct rb_class_cc_entries *)ccs_obj;
2225 const int ccs_len = ccs->len;
2226
2227 if (UNLIKELY(METHOD_ENTRY_INVALIDATED(ccs->cme))) {
2228 RB_VM_LOCKING() {
2229 vm_evict_cc(klass, cc_tbl, mid);
2230 }
2231 goto retry;
2232 }
2233 else {
2234 VM_ASSERT(vm_ccs_verify(ccs, mid, klass));
2235
2236 // We already know the method id is correct because we had
2237 // to look up the ccs_data by method id. We compare argc and
2238 // flag, plus the keyword argument count: two call sites with
2239 // the same argc and flag can still differ in how many of the
2240 // arguments are keywords (e.g. `m(a: 1, b: 2)` vs `m(1, b: 2)`),
2241 // which selects a different argument setup fastpath.
2242 const struct rb_callinfo_kwarg *kwarg = vm_ci_kwarg(ci);
2243 unsigned int argc = vm_ci_argc(ci);
2244 unsigned int flag = vm_ci_flag(ci);
2245 unsigned int kw_len = kwarg ? kwarg->keyword_len : 0;
2246
2247 for (int i=0; i<ccs_len; i++) {
2248 unsigned int ccs_ci_argc = ccs->entries[i].argc;
2249 unsigned int ccs_ci_flag = ccs->entries[i].flag;
2250 unsigned int ccs_ci_kw_len = ccs->entries[i].kw_len;
2251 const struct rb_callcache *ccs_cc = ccs->entries[i].cc;
2252
2253 VM_ASSERT(IMEMO_TYPE_P(ccs_cc, imemo_callcache));
2254
2255 if (ccs_ci_argc == argc && ccs_ci_flag == flag && ccs_ci_kw_len == kw_len) {
2256 RB_DEBUG_COUNTER_INC(cc_found_in_ccs);
2257
2258 VM_ASSERT(vm_cc_cme(ccs_cc)->called_id == mid);
2259 VM_ASSERT(ccs_cc->klass == klass);
2260 VM_ASSERT(!METHOD_ENTRY_INVALIDATED(vm_cc_cme(ccs_cc)));
2261
2262 return ccs_cc;
2263 }
2264 }
2265 }
2266 }
2267 }
2268
2269 RB_GC_GUARD(cc_tbl);
2270 return NULL;
2271}
2272
2273static const struct rb_callcache *
2274vm_search_cc(const VALUE klass, const struct rb_callinfo * const ci)
2275{
2276 const ID mid = vm_ci_mid(ci);
2277
2278 const struct rb_callcache *cc = vm_lookup_cc(klass, ci, mid);
2279 if (cc) {
2280 return cc;
2281 }
2282
2283 RB_VM_LOCKING() {
2284 if (rb_multi_ractor_p()) {
2285 // The CC may have been populated by another ractor while we were waiting on the lock,
2286 // so we must lookup a second time.
2287 cc = vm_lookup_cc(klass, ci, mid);
2288 }
2289
2290 if (!cc) {
2291 cc = vm_populate_cc(klass, ci, mid);
2292 }
2293 }
2294
2295 return cc;
2296}
2297
2298const struct rb_callcache *
2299rb_vm_search_method_slowpath(const struct rb_callinfo *ci, VALUE klass)
2300{
2301 const struct rb_callcache *cc;
2302
2303 VM_ASSERT_TYPE2(klass, T_CLASS, T_ICLASS);
2304
2305 cc = vm_search_cc(klass, ci);
2306
2307 VM_ASSERT(cc);
2308 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
2309 VM_ASSERT(cc == vm_cc_empty() || cc->klass == klass);
2310 VM_ASSERT(cc == vm_cc_empty() || callable_method_entry_p(vm_cc_cme(cc)));
2311 VM_ASSERT(cc == vm_cc_empty() || !METHOD_ENTRY_INVALIDATED(vm_cc_cme(cc)));
2312 VM_ASSERT(cc == vm_cc_empty() || vm_cc_cme(cc)->called_id == vm_ci_mid(ci));
2313
2314 return cc;
2315}
2316
2317static const struct rb_callcache *
2318vm_search_method_slowpath0(VALUE cd_owner, struct rb_call_data *cd, VALUE klass)
2319{
2320#if USE_DEBUG_COUNTER
2321 const struct rb_callcache *old_cc = cd->cc;
2322#endif
2323
2324 const struct rb_callcache *cc = rb_vm_search_method_slowpath(cd->ci, klass);
2325
2326#if OPT_INLINE_METHOD_CACHE
2327 cd->cc = cc;
2328
2329 const struct rb_callcache *empty_cc = &vm_empty_cc;
2330 if (cd_owner && cc != empty_cc) {
2331 RB_OBJ_WRITTEN(cd_owner, Qundef, cc);
2332 }
2333
2334#if USE_DEBUG_COUNTER
2335 if (!old_cc || old_cc == empty_cc) {
2336 // empty
2337 RB_DEBUG_COUNTER_INC(mc_inline_miss_empty);
2338 }
2339 else if (old_cc == cc) {
2340 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_cc);
2341 }
2342 else if (vm_cc_cme(old_cc) == vm_cc_cme(cc)) {
2343 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_cme);
2344 }
2345 else if (vm_cc_cme(old_cc) && vm_cc_cme(cc) &&
2346 vm_cc_cme(old_cc)->def == vm_cc_cme(cc)->def) {
2347 RB_DEBUG_COUNTER_INC(mc_inline_miss_same_def);
2348 }
2349 else {
2350 RB_DEBUG_COUNTER_INC(mc_inline_miss_diff);
2351 }
2352#endif
2353#endif // OPT_INLINE_METHOD_CACHE
2354
2355 VM_ASSERT(vm_cc_cme(cc) == NULL ||
2356 vm_cc_cme(cc)->called_id == vm_ci_mid(cd->ci));
2357
2358 return cc;
2359}
2360
2361ALWAYS_INLINE(static const struct rb_callcache *vm_search_method_fastpath(VALUE cd_owner, struct rb_call_data *cd, VALUE klass));
2362static const struct rb_callcache *
2363vm_search_method_fastpath(VALUE cd_owner, struct rb_call_data *cd, VALUE klass)
2364{
2365 const struct rb_callcache *cc = cd->cc;
2366
2367 VM_ASSERT_TYPE2(klass, T_CLASS, T_ICLASS);
2368
2369#if OPT_INLINE_METHOD_CACHE
2370 if (LIKELY(vm_cc_class_check(cc, klass))) {
2371 if (LIKELY(!METHOD_ENTRY_INVALIDATED(vm_cc_cme(cc)))) {
2372 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
2373 RB_DEBUG_COUNTER_INC(mc_inline_hit);
2374 VM_ASSERT(vm_cc_cme(cc) == NULL || // not found
2375 (vm_ci_flag(cd->ci) & VM_CALL_SUPER) || // search_super w/ define_method
2376 vm_cc_cme(cc)->called_id == vm_ci_mid(cd->ci)); // cme->called_id == ci->mid
2377
2378 return cc;
2379 }
2380 RB_DEBUG_COUNTER_INC(mc_inline_miss_invalidated);
2381 }
2382 else {
2383 RB_DEBUG_COUNTER_INC(mc_inline_miss_klass);
2384 }
2385#endif
2386
2387 return vm_search_method_slowpath0(cd_owner, cd, klass);
2388}
2389
2390static const struct rb_callable_method_entry_struct *
2391vm_search_method(VALUE cd_owner, struct rb_call_data *cd, VALUE recv)
2392{
2393 VALUE klass = CLASS_OF(recv);
2394 VM_ASSERT(klass != Qfalse);
2395 VM_ASSERT(RBASIC_CLASS(klass) == 0 || rb_obj_is_kind_of(klass, rb_cClass));
2396
2397 const struct rb_callcache *cc = vm_search_method_fastpath(cd_owner, cd, klass);
2398 return vm_cc_cme(cc);
2399}
2400
2402rb_zjit_vm_search_method(VALUE cd_owner, struct rb_call_data *cd, VALUE recv)
2403{
2404 return vm_search_method(cd_owner, cd, recv);
2405}
2406
2407#if __has_attribute(transparent_union)
2408typedef union {
2409 VALUE (*anyargs)(ANYARGS);
2410 VALUE (*f00)(VALUE);
2411 VALUE (*f01)(VALUE, VALUE);
2412 VALUE (*f02)(VALUE, VALUE, VALUE);
2413 VALUE (*f03)(VALUE, VALUE, VALUE, VALUE);
2414 VALUE (*f04)(VALUE, VALUE, VALUE, VALUE, VALUE);
2415 VALUE (*f05)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
2416 VALUE (*f06)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
2417 VALUE (*f07)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE, VALUE);
2426 VALUE (*fm1)(int, union { VALUE *x; const VALUE *y; } __attribute__((__transparent_union__)), VALUE);
2427} __attribute__((__transparent_union__)) cfunc_type;
2428# define make_cfunc_type(f) (cfunc_type){.anyargs = (VALUE (*)(ANYARGS))(f)}
2429#else
2430typedef VALUE (*cfunc_type)(ANYARGS);
2431# define make_cfunc_type(f) (cfunc_type)(f)
2432#endif
2433
2434static inline int
2435check_cfunc(const rb_callable_method_entry_t *me, cfunc_type func)
2436{
2437 if (! me) {
2438 return false;
2439 }
2440 else {
2441 VM_ASSERT(IMEMO_TYPE_P(me, imemo_ment));
2442 VM_ASSERT(callable_method_entry_p(me));
2443 VM_ASSERT(me->def);
2444 if (me->def->type != VM_METHOD_TYPE_CFUNC) {
2445 return false;
2446 }
2447 else {
2448#if __has_attribute(transparent_union)
2449 return me->def->body.cfunc.func == func.anyargs;
2450#else
2451 return me->def->body.cfunc.func == func;
2452#endif
2453 }
2454 }
2455}
2456
2457static inline int
2458check_method_basic_definition(const rb_callable_method_entry_t *me)
2459{
2460 return me && METHOD_ENTRY_BASIC(me);
2461}
2462
2463static inline int
2464vm_method_cfunc_is(const rb_iseq_t *iseq, CALL_DATA cd, VALUE recv, cfunc_type func)
2465{
2466 VM_ASSERT(iseq != NULL);
2467 const struct rb_callable_method_entry_struct *cme = vm_search_method((VALUE)iseq, cd, recv);
2468 return check_cfunc(cme, func);
2469}
2470
2471bool
2472rb_zjit_cme_is_cfunc(const rb_callable_method_entry_t *me, const cfunc_type func)
2473{
2474 return check_cfunc(me, func);
2475}
2476
2477int
2478rb_vm_method_cfunc_is(const rb_iseq_t *iseq, CALL_DATA cd, VALUE recv, cfunc_type func)
2479{
2480 return vm_method_cfunc_is(iseq, cd, recv, func);
2481}
2482
2483#define check_cfunc(me, func) check_cfunc(me, make_cfunc_type(func))
2484#define vm_method_cfunc_is(iseq, cd, recv, func) vm_method_cfunc_is(iseq, cd, recv, make_cfunc_type(func))
2485
2486#define EQ_UNREDEFINED_P(t) BASIC_OP_UNREDEFINED_P(BOP_EQ, t##_REDEFINED_OP_FLAG)
2487
2488static inline bool
2489FIXNUM_2_P(VALUE a, VALUE b)
2490{
2491 /* FIXNUM_P(a) && FIXNUM_P(b)
2492 * == ((a & 1) && (b & 1))
2493 * == a & b & 1 */
2494 SIGNED_VALUE x = a;
2495 SIGNED_VALUE y = b;
2496 SIGNED_VALUE z = x & y & 1;
2497 return z == 1;
2498}
2499
2500static inline bool
2501FLONUM_2_P(VALUE a, VALUE b)
2502{
2503#if USE_FLONUM
2504 /* FLONUM_P(a) && FLONUM_P(b)
2505 * == ((a & 3) == 2) && ((b & 3) == 2)
2506 * == ! ((a ^ 2) | (b ^ 2) & 3)
2507 */
2508 SIGNED_VALUE x = a;
2509 SIGNED_VALUE y = b;
2510 SIGNED_VALUE z = ((x ^ 2) | (y ^ 2)) & 3;
2511 return !z;
2512#else
2513 return false;
2514#endif
2515}
2516
2517static VALUE
2518opt_equality_specialized(VALUE recv, VALUE obj)
2519{
2520 if (FIXNUM_2_P(recv, obj) && EQ_UNREDEFINED_P(INTEGER)) {
2521 goto compare_by_identity;
2522 }
2523 else if (FLONUM_2_P(recv, obj) && EQ_UNREDEFINED_P(FLOAT)) {
2524 goto compare_by_identity;
2525 }
2526 else if (STATIC_SYM_P(recv) && STATIC_SYM_P(obj) && EQ_UNREDEFINED_P(SYMBOL)) {
2527 goto compare_by_identity;
2528 }
2529 else if (SPECIAL_CONST_P(recv)) {
2530 //
2531 }
2532 else if (RBASIC_CLASS(recv) == rb_cFloat && RB_FLOAT_TYPE_P(obj) && EQ_UNREDEFINED_P(FLOAT)) {
2533 double a = RFLOAT_VALUE(recv);
2534 double b = RFLOAT_VALUE(obj);
2535
2536 return RBOOL(a == b);
2537 }
2538 else if (RBASIC_CLASS(recv) == rb_cString && EQ_UNREDEFINED_P(STRING)) {
2539 if (recv == obj) {
2540 return Qtrue;
2541 }
2542 else if (RB_TYPE_P(obj, T_STRING)) {
2543 return rb_str_eql_internal(obj, recv);
2544 }
2545 }
2546 return Qundef;
2547
2548 compare_by_identity:
2549 return RBOOL(recv == obj);
2550}
2551
2552static VALUE
2553opt_equality(const rb_iseq_t *cd_owner, VALUE recv, VALUE obj, CALL_DATA cd)
2554{
2555 VM_ASSERT(cd_owner != NULL);
2556
2557 VALUE val = opt_equality_specialized(recv, obj);
2558 if (!UNDEF_P(val)) return val;
2559
2560 if (!vm_method_cfunc_is(cd_owner, cd, recv, rb_obj_equal)) {
2561 return Qundef;
2562 }
2563 else {
2564 return RBOOL(recv == obj);
2565 }
2566}
2567
2568#undef EQ_UNREDEFINED_P
2569
2570static inline const struct rb_callcache *gccct_method_search(rb_execution_context_t *ec, VALUE recv, ID mid, const struct rb_callinfo *ci); // vm_eval.c
2571NOINLINE(static VALUE opt_equality_by_mid_slowpath(VALUE recv, VALUE obj, ID mid));
2572
2573static VALUE
2574opt_equality_by_mid_slowpath(VALUE recv, VALUE obj, ID mid)
2575{
2576 const struct rb_callcache *cc = gccct_method_search(GET_EC(), recv, mid, &VM_CI_ON_STACK(mid, 0, 1, NULL));
2577
2578 if (cc && check_cfunc(vm_cc_cme(cc), rb_obj_equal)) {
2579 return RBOOL(recv == obj);
2580 }
2581 else {
2582 return Qundef;
2583 }
2584}
2585
2586static VALUE
2587opt_equality_by_mid(VALUE recv, VALUE obj, ID mid)
2588{
2589 VALUE val = opt_equality_specialized(recv, obj);
2590 if (!UNDEF_P(val)) {
2591 return val;
2592 }
2593 else {
2594 return opt_equality_by_mid_slowpath(recv, obj, mid);
2595 }
2596}
2597
2598VALUE
2599rb_equal_opt(VALUE obj1, VALUE obj2)
2600{
2601 return opt_equality_by_mid(obj1, obj2, idEq);
2602}
2603
2604VALUE
2605rb_eql_opt(VALUE obj1, VALUE obj2)
2606{
2607 return opt_equality_by_mid(obj1, obj2, idEqlP);
2608}
2609
2610extern VALUE rb_vm_call0(rb_execution_context_t *ec, VALUE, ID, int, const VALUE*, const rb_callable_method_entry_t *, int kw_splat);
2611extern VALUE rb_vm_call_with_refinements(rb_execution_context_t *, VALUE, ID, int, const VALUE *, int);
2612
2613static VALUE
2614check_match(rb_execution_context_t *ec, VALUE pattern, VALUE target, enum vm_check_match_type type)
2615{
2616 switch (type) {
2617 case VM_CHECKMATCH_TYPE_WHEN:
2618 return pattern;
2619 case VM_CHECKMATCH_TYPE_RESCUE:
2620 if (!rb_obj_is_kind_of(pattern, rb_cModule)) {
2621 rb_raise(rb_eTypeError, "class or module required for rescue clause");
2622 }
2623 /* fall through */
2624 case VM_CHECKMATCH_TYPE_CASE: {
2625 return rb_vm_call_with_refinements(ec, pattern, idEqq, 1, &target, RB_NO_KEYWORDS);
2626 }
2627 default:
2628 rb_bug("check_match: unreachable");
2629 }
2630}
2631
2632
2633static inline VALUE
2634double_cmp_lt(double a, double b)
2635{
2636 return RBOOL(a < b);
2637}
2638
2639static inline VALUE
2640double_cmp_le(double a, double b)
2641{
2642 return RBOOL(a <= b);
2643}
2644
2645static inline VALUE
2646double_cmp_gt(double a, double b)
2647{
2648 return RBOOL(a > b);
2649}
2650
2651static inline VALUE
2652double_cmp_ge(double a, double b)
2653{
2654 return RBOOL(a >= b);
2655}
2656
2657// Copied by vm_dump.c
2658static inline VALUE *
2659vm_base_ptr(const rb_control_frame_t *cfp)
2660{
2661 const rb_control_frame_t *prev_cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
2662
2663 if (cfp->iseq && VM_FRAME_RUBYFRAME_P(cfp)) {
2664 VALUE *bp = prev_cfp->sp + ISEQ_BODY(cfp->iseq)->local_table_size + VM_ENV_DATA_SIZE;
2665
2666 if (ISEQ_BODY(cfp->iseq)->param.flags.forwardable && VM_ENV_LOCAL_P(cfp->ep)) {
2667 int lts = ISEQ_BODY(cfp->iseq)->local_table_size;
2668 int params = ISEQ_BODY(cfp->iseq)->param.size;
2669
2670 CALL_INFO ci = (CALL_INFO)cfp->ep[-(VM_ENV_DATA_SIZE + (lts - params))]; // skip EP stuff, CI should be last local
2671 bp += vm_ci_argc(ci);
2672 }
2673
2674 if (ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_METHOD || VM_FRAME_BMETHOD_P(cfp)) {
2675 /* adjust `self' */
2676 bp += 1;
2677 }
2678#if VM_DEBUG_BP_CHECK
2679 if (bp != cfp->bp_check) {
2680 ruby_debug_printf("bp_check: %ld, bp: %ld\n",
2681 (long)(cfp->bp_check - GET_EC()->vm_stack),
2682 (long)(bp - GET_EC()->vm_stack));
2683 rb_bug("vm_base_ptr: unreachable");
2684 }
2685#endif
2686 return bp;
2687 }
2688 else {
2689 return NULL;
2690 }
2691}
2692
2693VALUE *
2694rb_vm_base_ptr(const rb_control_frame_t *cfp)
2695{
2696 return vm_base_ptr(cfp);
2697}
2698
2699/* method call processes with call_info */
2700
2701#include "vm_args.c"
2702
2703static inline VALUE vm_call_iseq_setup_2(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, int opt_pc, int param_size, int local_size);
2704ALWAYS_INLINE(static VALUE vm_call_iseq_setup_normal(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, const rb_callable_method_entry_t *me, int opt_pc, int param_size, int local_size));
2705static inline VALUE vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, int opt_pc);
2706static VALUE vm_call_super_method(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling);
2707static VALUE vm_call_method_nome(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling);
2708static VALUE vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling);
2709static inline VALUE vm_call_method(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling);
2710
2711static vm_call_handler vm_call_iseq_setup_func(const struct rb_callinfo *ci, const int param_size, const int local_size);
2712
2713static VALUE
2714vm_call_iseq_setup_tailcall_0start(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
2715{
2716 RB_DEBUG_COUNTER_INC(ccf_iseq_setup_tailcall_0start);
2717
2718 return vm_call_iseq_setup_tailcall(ec, cfp, calling, 0);
2719}
2720
2721static VALUE
2722vm_call_iseq_setup_normal_0start(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
2723{
2724 RB_DEBUG_COUNTER_INC(ccf_iseq_setup_0start);
2725
2726 const struct rb_callcache *cc = calling->cc;
2727 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
2728 int param = ISEQ_BODY(iseq)->param.size;
2729 int local = ISEQ_BODY(iseq)->local_table_size;
2730 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
2731}
2732
2733bool
2734rb_simple_iseq_p(const rb_iseq_t *iseq)
2735{
2736 return ISEQ_BODY(iseq)->param.flags.has_opt == FALSE &&
2737 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2738 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2739 ISEQ_BODY(iseq)->param.flags.has_kw == FALSE &&
2740 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2741 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg == FALSE &&
2742 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2743 ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
2744}
2745
2746bool
2747rb_iseq_only_optparam_p(const rb_iseq_t *iseq)
2748{
2749 return ISEQ_BODY(iseq)->param.flags.has_opt == TRUE &&
2750 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2751 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2752 ISEQ_BODY(iseq)->param.flags.has_kw == FALSE &&
2753 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2754 ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg == FALSE &&
2755 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2756 ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
2757}
2758
2759bool
2760rb_iseq_only_kwparam_p(const rb_iseq_t *iseq)
2761{
2762 return ISEQ_BODY(iseq)->param.flags.has_opt == FALSE &&
2763 ISEQ_BODY(iseq)->param.flags.has_rest == FALSE &&
2764 ISEQ_BODY(iseq)->param.flags.has_post == FALSE &&
2765 ISEQ_BODY(iseq)->param.flags.has_kw == TRUE &&
2766 ISEQ_BODY(iseq)->param.flags.has_kwrest == FALSE &&
2767 ISEQ_BODY(iseq)->param.flags.forwardable == FALSE &&
2768 ISEQ_BODY(iseq)->param.flags.has_block == FALSE;
2769}
2770
2771#define ALLOW_HEAP_ARGV (-2)
2772#define ALLOW_HEAP_ARGV_KEEP_KWSPLAT (-3)
2773
2774static inline bool
2775vm_caller_setup_arg_splat(rb_control_frame_t *cfp, struct rb_calling_info *calling, VALUE ary, int max_args)
2776{
2777 vm_check_canary(GET_EC(), cfp->sp);
2778 bool ret = false;
2779
2780 if (!NIL_P(ary)) {
2781 const VALUE *ptr = RARRAY_CONST_PTR(ary);
2782 long len = RARRAY_LEN(ary);
2783 int argc = calling->argc;
2784
2785 if (UNLIKELY(max_args <= ALLOW_HEAP_ARGV && len + argc > VM_ARGC_STACK_MAX)) {
2786 /* Avoid SystemStackError when splatting large arrays by storing arguments in
2787 * a temporary array, instead of trying to keeping arguments on the VM stack.
2788 */
2789 VALUE *argv = cfp->sp - argc;
2790 VALUE argv_ary = rb_ary_hidden_new(len + argc + 1);
2791 rb_ary_cat(argv_ary, argv, argc);
2792 rb_ary_cat(argv_ary, ptr, len);
2793 cfp->sp -= argc - 1;
2794 cfp->sp[-1] = argv_ary;
2795 calling->argc = 1;
2796 calling->heap_argv = argv_ary;
2797 RB_GC_GUARD(ary);
2798 }
2799 else {
2800 long i;
2801
2802 if (max_args >= 0 && len + argc > max_args) {
2803 /* If only a given max_args is allowed, copy up to max args.
2804 * Used by vm_callee_setup_block_arg for non-lambda blocks,
2805 * where additional arguments are ignored.
2806 *
2807 * Also, copy up to one more argument than the maximum,
2808 * in case it is an empty keyword hash that will be removed.
2809 */
2810 calling->argc += len - (max_args - argc + 1);
2811 len = max_args - argc + 1;
2812 ret = true;
2813 }
2814 else {
2815 /* Unset heap_argv if set originally. Can happen when
2816 * forwarding modified arguments, where heap_argv was used
2817 * originally, but heap_argv not supported by the forwarded
2818 * method in all cases.
2819 */
2820 calling->heap_argv = 0;
2821 }
2822 CHECK_VM_STACK_OVERFLOW(cfp, len);
2823
2824 for (i = 0; i < len; i++) {
2825 *cfp->sp++ = ptr[i];
2826 }
2827 calling->argc += i;
2828 }
2829 }
2830
2831 return ret;
2832}
2833
2834static inline void
2835vm_caller_setup_arg_kw(rb_control_frame_t *cfp, struct rb_calling_info *calling, const struct rb_callinfo *ci)
2836{
2837 const VALUE *const passed_keywords = vm_ci_kwarg(ci)->keywords;
2838 const int kw_len = vm_ci_kwarg(ci)->keyword_len;
2839 const VALUE h = rb_hash_new_with_size(kw_len);
2840 VALUE *sp = cfp->sp;
2841 int i;
2842
2843 for (i=0; i<kw_len; i++) {
2844 rb_hash_aset(h, passed_keywords[i], (sp - kw_len)[i]);
2845 }
2846 (sp-kw_len)[0] = h;
2847
2848 cfp->sp -= kw_len - 1;
2849 calling->argc -= kw_len - 1;
2850 calling->kw_splat = 1;
2851}
2852
2853static inline VALUE
2854vm_caller_setup_keyword_hash(const struct rb_callinfo *ci, VALUE keyword_hash)
2855{
2856 if (UNLIKELY(!RB_TYPE_P(keyword_hash, T_HASH))) {
2857 if (keyword_hash != Qnil) {
2858 /* Convert a non-hash keyword splat to a new hash */
2859 keyword_hash = rb_hash_dup(rb_to_hash_type(keyword_hash));
2860 }
2861 }
2862 else if (!IS_ARGS_KW_SPLAT_MUT(ci) && !RHASH_EMPTY_P(keyword_hash)) {
2863 /* Convert a hash keyword splat to a new hash unless
2864 * a mutable keyword splat was passed.
2865 * Skip allocating new hash for empty keyword splat, as empty
2866 * keyword splat will be ignored by both callers.
2867 */
2868 keyword_hash = rb_hash_dup(keyword_hash);
2869 }
2870 return keyword_hash;
2871}
2872
2873static inline void
2874CALLER_SETUP_ARG(struct rb_control_frame_struct *restrict cfp,
2875 struct rb_calling_info *restrict calling,
2876 const struct rb_callinfo *restrict ci, int max_args)
2877{
2878 if (UNLIKELY(IS_ARGS_SPLAT(ci))) {
2879 if (IS_ARGS_KW_SPLAT(ci)) {
2880 // f(*a, **kw)
2881 VM_ASSERT(calling->kw_splat == 1);
2882
2883 cfp->sp -= 2;
2884 calling->argc -= 2;
2885 VALUE ary = cfp->sp[0];
2886 VALUE kwh = vm_caller_setup_keyword_hash(ci, cfp->sp[1]);
2887
2888 // splat a
2889 if (vm_caller_setup_arg_splat(cfp, calling, ary, max_args)) return;
2890
2891 // put kw
2892 if (kwh != Qnil && !RHASH_EMPTY_P(kwh)) {
2893 if (UNLIKELY(calling->heap_argv)) {
2894 rb_ary_push(calling->heap_argv, kwh);
2895 ((struct RHash *)kwh)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
2896 if (max_args != ALLOW_HEAP_ARGV_KEEP_KWSPLAT) {
2897 calling->kw_splat = 0;
2898 }
2899 }
2900 else {
2901 cfp->sp[0] = kwh;
2902 cfp->sp++;
2903 calling->argc++;
2904
2905 VM_ASSERT(calling->kw_splat == 1);
2906 }
2907 }
2908 else {
2909 calling->kw_splat = 0;
2910 }
2911 }
2912 else {
2913 // f(*a)
2914 VM_ASSERT(calling->kw_splat == 0);
2915
2916 cfp->sp -= 1;
2917 calling->argc -= 1;
2918 VALUE ary = cfp->sp[0];
2919
2920 if (vm_caller_setup_arg_splat(cfp, calling, ary, max_args)) {
2921 goto check_keyword;
2922 }
2923
2924 // check the last argument
2925 VALUE last_hash, argv_ary;
2926 if (UNLIKELY(argv_ary = calling->heap_argv)) {
2927 if (!IS_ARGS_KEYWORD(ci) &&
2928 RARRAY_LEN(argv_ary) > 0 &&
2929 RB_TYPE_P((last_hash = rb_ary_last(0, NULL, argv_ary)), T_HASH) &&
2930 (((struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS)) {
2931
2932 rb_ary_pop(argv_ary);
2933 if (!RHASH_EMPTY_P(last_hash)) {
2934 rb_ary_push(argv_ary, rb_hash_dup(last_hash));
2935 calling->kw_splat = 1;
2936 }
2937 }
2938 }
2939 else {
2940check_keyword:
2941 if (!IS_ARGS_KEYWORD(ci) &&
2942 calling->argc > 0 &&
2943 RB_TYPE_P((last_hash = cfp->sp[-1]), T_HASH) &&
2944 (((struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS)) {
2945
2946 if (RHASH_EMPTY_P(last_hash)) {
2947 calling->argc--;
2948 cfp->sp -= 1;
2949 }
2950 else {
2951 cfp->sp[-1] = rb_hash_dup(last_hash);
2952 calling->kw_splat = 1;
2953 }
2954 }
2955 }
2956 }
2957 }
2958 else if (UNLIKELY(IS_ARGS_KW_SPLAT(ci))) {
2959 // f(**kw)
2960 VM_ASSERT(calling->kw_splat == 1);
2961 VALUE kwh = vm_caller_setup_keyword_hash(ci, cfp->sp[-1]);
2962
2963 if (kwh == Qnil || RHASH_EMPTY_P(kwh)) {
2964 cfp->sp--;
2965 calling->argc--;
2966 calling->kw_splat = 0;
2967 }
2968 else {
2969 cfp->sp[-1] = kwh;
2970 }
2971 }
2972 else if (UNLIKELY(IS_ARGS_KEYWORD(ci))) {
2973 // f(k1:1, k2:2)
2974 VM_ASSERT(calling->kw_splat == 0);
2975
2976 /* This converts VM_CALL_KWARG style to VM_CALL_KW_SPLAT style
2977 * by creating a keyword hash.
2978 * So, vm_ci_flag(ci) & VM_CALL_KWARG is now inconsistent.
2979 */
2980 vm_caller_setup_arg_kw(cfp, calling, ci);
2981 }
2982}
2983
2984#define USE_OPT_HIST 0
2985
2986#if USE_OPT_HIST
2987#define OPT_HIST_MAX 64
2988static int opt_hist[OPT_HIST_MAX+1];
2989
2990__attribute__((destructor))
2991static void
2992opt_hist_show_results_at_exit(void)
2993{
2994 for (int i=0; i<OPT_HIST_MAX; i++) {
2995 ruby_debug_printf("opt_hist\t%d\t%d\n", i, opt_hist[i]);
2996 }
2997}
2998#endif
2999
3000static VALUE
3001vm_call_iseq_setup_normal_opt_start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3002 struct rb_calling_info *calling)
3003{
3004 const struct rb_callcache *cc = calling->cc;
3005 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3006 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3007 const int opt = calling->argc - lead_num;
3008 const int opt_num = ISEQ_BODY(iseq)->param.opt_num;
3009 const int opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
3010 const int param = ISEQ_BODY(iseq)->param.size;
3011 const int local = ISEQ_BODY(iseq)->local_table_size;
3012 const int delta = opt_num - opt;
3013
3014 RB_DEBUG_COUNTER_INC(ccf_iseq_opt);
3015
3016#if USE_OPT_HIST
3017 if (opt_pc < OPT_HIST_MAX) {
3018 opt_hist[opt]++;
3019 }
3020 else {
3021 opt_hist[OPT_HIST_MAX]++;
3022 }
3023#endif
3024
3025 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), opt_pc, param - delta, local);
3026}
3027
3028static VALUE
3029vm_call_iseq_setup_tailcall_opt_start(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3030 struct rb_calling_info *calling)
3031{
3032 const struct rb_callcache *cc = calling->cc;
3033 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3034 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3035 const int opt = calling->argc - lead_num;
3036 const int opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt];
3037
3038 RB_DEBUG_COUNTER_INC(ccf_iseq_opt);
3039
3040#if USE_OPT_HIST
3041 if (opt_pc < OPT_HIST_MAX) {
3042 opt_hist[opt]++;
3043 }
3044 else {
3045 opt_hist[OPT_HIST_MAX]++;
3046 }
3047#endif
3048
3049 return vm_call_iseq_setup_tailcall(ec, cfp, calling, opt_pc);
3050}
3051
3052static void
3053args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *const iseq, const rb_callable_method_entry_t *cme,
3054 VALUE *const passed_values, const int passed_keyword_len, const VALUE *const passed_keywords,
3055 VALUE *const locals);
3056
3057static VALUE
3058vm_call_iseq_forwardable(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3059 struct rb_calling_info *calling)
3060{
3061 const struct rb_callcache *cc = calling->cc;
3062 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3063 int param_size = ISEQ_BODY(iseq)->param.size;
3064 int local_size = ISEQ_BODY(iseq)->local_table_size;
3065
3066 // Setting up local size and param size
3067 VM_ASSERT(ISEQ_BODY(iseq)->param.flags.forwardable);
3068
3069 local_size = local_size + vm_ci_argc(calling->cd->ci);
3070 param_size = param_size + vm_ci_argc(calling->cd->ci);
3071
3072 cfp->sp[0] = (VALUE)calling->cd->ci;
3073
3074 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param_size, local_size);
3075}
3076
3077static VALUE
3078vm_call_iseq_setup_kwparm_kwarg(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3079 struct rb_calling_info *calling)
3080{
3081 const struct rb_callinfo *ci = calling->cd->ci;
3082 const struct rb_callcache *cc = calling->cc;
3083
3084 VM_ASSERT(vm_ci_flag(ci) & VM_CALL_KWARG);
3085 RB_DEBUG_COUNTER_INC(ccf_iseq_kw1);
3086
3087 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3088 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3089 const struct rb_callinfo_kwarg *kw_arg = vm_ci_kwarg(ci);
3090 const int ci_kw_len = kw_arg->keyword_len;
3091 const VALUE * const ci_keywords = kw_arg->keywords;
3092 VALUE *argv = cfp->sp - calling->argc;
3093 VALUE *const klocals = argv + kw_param->bits_start - kw_param->num;
3094 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3095 VALUE * const ci_kws = ALLOCA_N(VALUE, ci_kw_len);
3096 MEMCPY(ci_kws, argv + lead_num, VALUE, ci_kw_len);
3097 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), ci_kws, ci_kw_len, ci_keywords, klocals);
3098
3099 int param = ISEQ_BODY(iseq)->param.size;
3100 int local = ISEQ_BODY(iseq)->local_table_size;
3101 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
3102}
3103
3104static VALUE
3105vm_call_iseq_setup_kwparm_nokwarg(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3106 struct rb_calling_info *calling)
3107{
3108 const struct rb_callinfo *MAYBE_UNUSED(ci) = calling->cd->ci;
3109 const struct rb_callcache *cc = calling->cc;
3110
3111 VM_ASSERT((vm_ci_flag(ci) & VM_CALL_KWARG) == 0);
3112 RB_DEBUG_COUNTER_INC(ccf_iseq_kw2);
3113
3114 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3115 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3116 VALUE * const argv = cfp->sp - calling->argc;
3117 VALUE * const klocals = argv + kw_param->bits_start - kw_param->num;
3118
3119 int i;
3120 for (i=0; i<kw_param->num; i++) {
3121 klocals[i] = kw_param->default_values[i];
3122 }
3123 klocals[i] = INT2FIX(0); // kw specify flag
3124 // NOTE:
3125 // nobody check this value, but it should be cleared because it can
3126 // points invalid VALUE (T_NONE objects, raw pointer and so on).
3127
3128 int param = ISEQ_BODY(iseq)->param.size;
3129 int local = ISEQ_BODY(iseq)->local_table_size;
3130 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), 0, param, local);
3131}
3132
3133static VALUE builtin_invoker0(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr);
3134
3135static VALUE
3136vm_call_single_noarg_leaf_builtin(rb_execution_context_t *ec, rb_control_frame_t *cfp,
3137 struct rb_calling_info *calling)
3138{
3139 const struct rb_callcache *cc = calling->cc;
3140 // Pairs with the release store in vm_callee_setup_arg so aux_.bf is visible.
3141 vm_call_handler call = (vm_call_handler)(uintptr_t)rbimpl_atomic_ptr_load((void **)&cc->call_, RBIMPL_ATOMIC_ACQUIRE);
3142 if (UNLIKELY(call != vm_call_single_noarg_leaf_builtin)) {
3143 return call(ec, cfp, calling);
3144 }
3145 const struct rb_builtin_function *bf = cc->aux_.bf;
3146 cfp->sp -= (calling->argc + 1);
3147 rb_insn_func_t func_ptr = (rb_insn_func_t)(uintptr_t)bf->func_ptr;
3148 return builtin_invoker0(ec, calling->recv, NULL, func_ptr);
3149}
3150
3151VALUE rb_gen_method_name(VALUE owner, VALUE name); // in vm_backtrace.c
3152
3153static void
3154warn_unused_block(const rb_callable_method_entry_t *cme, const rb_iseq_t *iseq, void *pc)
3155{
3156 rb_vm_t *vm = GET_VM();
3157 set_table *dup_check_table = vm->unused_block_warning_table;
3158 st_data_t key;
3159 bool strict_unused_block = rb_warning_category_enabled_p(RB_WARN_CATEGORY_STRICT_UNUSED_BLOCK);
3160
3161 union {
3162 VALUE v;
3163 unsigned char b[SIZEOF_VALUE];
3164 } k1 = {
3165 .v = (VALUE)pc,
3166 }, k2 = {
3167 .v = (VALUE)cme->def,
3168 };
3169
3170 // relax check
3171 if (!strict_unused_block) {
3172 key = (st_data_t)cme->def->original_id;
3173
3174 if (set_table_lookup(dup_check_table, key)) {
3175 return;
3176 }
3177 }
3178
3179 // strict check
3180 // make unique key from pc and me->def pointer
3181 key = 0;
3182 for (int i=0; i<SIZEOF_VALUE; i++) {
3183 // fprintf(stderr, "k1:%3d k2:%3d\n", k1.b[i], k2.b[SIZEOF_VALUE-1-i]);
3184 key |= (st_data_t)(k1.b[i] ^ k2.b[SIZEOF_VALUE-1-i]) << (8 * i);
3185 }
3186
3187 if (0) {
3188 fprintf(stderr, "SIZEOF_VALUE:%d\n", SIZEOF_VALUE);
3189 fprintf(stderr, "pc:%p def:%p\n", pc, (void *)cme->def);
3190 fprintf(stderr, "key:%p\n", (void *)key);
3191 }
3192
3193 // duplication check
3194 if (set_insert(dup_check_table, key)) {
3195 // already shown
3196 }
3197 else if (RTEST(ruby_verbose) || strict_unused_block) {
3198 VALUE m_loc = rb_method_entry_location((const rb_method_entry_t *)cme);
3199 VALUE name = rb_gen_method_name(cme->defined_class, ISEQ_BODY(iseq)->location.base_label);
3200
3201 if (!NIL_P(m_loc)) {
3202 rb_warn("the block passed to '%"PRIsVALUE"' defined at %"PRIsVALUE":%"PRIsVALUE" may be ignored",
3203 name, RARRAY_AREF(m_loc, 0), RARRAY_AREF(m_loc, 1));
3204 }
3205 else {
3206 rb_warn("the block may be ignored because '%"PRIsVALUE"' does not use a block", name);
3207 }
3208 }
3209}
3210
3211static inline int
3212vm_callee_setup_arg(rb_execution_context_t *ec, struct rb_calling_info *calling,
3213 const rb_iseq_t *iseq, VALUE *argv, int param_size, int local_size)
3214{
3215 const struct rb_callinfo *ci = calling->cd->ci;
3216 const struct rb_callcache *cc = calling->cc;
3217
3218 VM_ASSERT((vm_ci_argc(ci), 1));
3219 VM_ASSERT(vm_cc_cme(cc) != NULL);
3220
3221 if (UNLIKELY(!ISEQ_BODY(iseq)->param.flags.use_block &&
3222 calling->block_handler != VM_BLOCK_HANDLER_NONE &&
3223 !(vm_ci_flag(calling->cd->ci) & (VM_CALL_OPT_SEND | VM_CALL_SUPER)))) {
3224 warn_unused_block(vm_cc_cme(cc), iseq, (void *)ec->cfp->pc);
3225 }
3226
3227 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_KW_SPLAT))) {
3228 if (LIKELY(rb_simple_iseq_p(iseq))) {
3229 rb_control_frame_t *cfp = ec->cfp;
3230 int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3231 CALLER_SETUP_ARG(cfp, calling, ci, lead_num);
3232
3233 if (calling->argc != lead_num) {
3234 argument_arity_error(ec, iseq, vm_cc_cme(cc), calling->argc, lead_num, lead_num);
3235 }
3236
3237 //VM_ASSERT(ci == calling->cd->ci);
3238 VM_ASSERT(cc == calling->cc);
3239
3240 if (vm_call_iseq_optimizable_p(ci, cc)) {
3241 if ((ISEQ_BODY(iseq)->builtin_attrs & BUILTIN_ATTR_SINGLE_NOARG_LEAF) && ruby_vm_c_events_enabled == 0) {
3242 VM_ASSERT(ISEQ_BODY(iseq)->builtin_attrs & BUILTIN_ATTR_LEAF);
3243 vm_cc_bf_set(cc, (void *)ISEQ_BODY(iseq)->iseq_encoded[1]);
3244 rbimpl_atomic_ptr_store((volatile void **)&cc->call_,
3245 (void *)(uintptr_t)vm_call_single_noarg_leaf_builtin,
3246 RBIMPL_ATOMIC_RELEASE);
3247 }
3248 else {
3249 CC_SET_FASTPATH(cc, vm_call_iseq_setup_func(ci, param_size, local_size), true);
3250 }
3251 }
3252 return 0;
3253 }
3254 else if (rb_iseq_only_optparam_p(iseq)) {
3255 rb_control_frame_t *cfp = ec->cfp;
3256
3257 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3258 const int opt_num = ISEQ_BODY(iseq)->param.opt_num;
3259
3260 CALLER_SETUP_ARG(cfp, calling, ci, lead_num + opt_num);
3261 const int argc = calling->argc;
3262 const int opt = argc - lead_num;
3263
3264 if (opt < 0 || opt > opt_num) {
3265 argument_arity_error(ec, iseq, vm_cc_cme(cc), argc, lead_num, lead_num + opt_num);
3266 }
3267
3268 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {
3269 CC_SET_FASTPATH(cc, vm_call_iseq_setup_normal_opt_start,
3270 !IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&
3271 vm_call_cacheable(ci, cc));
3272 }
3273 else {
3274 CC_SET_FASTPATH(cc, vm_call_iseq_setup_tailcall_opt_start,
3275 !IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&
3276 vm_call_cacheable(ci, cc));
3277 }
3278
3279 /* initialize opt vars for self-references */
3280 VM_ASSERT((int)ISEQ_BODY(iseq)->param.size == lead_num + opt_num);
3281 for (int i=argc; i<lead_num + opt_num; i++) {
3282 argv[i] = Qnil;
3283 }
3284 return (int)ISEQ_BODY(iseq)->param.opt_table[opt];
3285 }
3286 else if (rb_iseq_only_kwparam_p(iseq) && !IS_ARGS_SPLAT(ci)) {
3287 const int lead_num = ISEQ_BODY(iseq)->param.lead_num;
3288 const int argc = calling->argc;
3289 const struct rb_iseq_param_keyword *kw_param = ISEQ_BODY(iseq)->param.keyword;
3290
3291 if (vm_ci_flag(ci) & VM_CALL_KWARG) {
3292 const struct rb_callinfo_kwarg *kw_arg = vm_ci_kwarg(ci);
3293
3294 if (argc - kw_arg->keyword_len == lead_num) {
3295 const int ci_kw_len = kw_arg->keyword_len;
3296 const VALUE * const ci_keywords = kw_arg->keywords;
3297 VALUE * const ci_kws = ALLOCA_N(VALUE, ci_kw_len);
3298 MEMCPY(ci_kws, argv + lead_num, VALUE, ci_kw_len);
3299
3300 VALUE *const klocals = argv + kw_param->bits_start - kw_param->num;
3301 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), ci_kws, ci_kw_len, ci_keywords, klocals);
3302
3303 CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_kwarg,
3304 vm_call_cacheable(ci, cc));
3305
3306 return 0;
3307 }
3308 }
3309 else if (argc == lead_num) {
3310 /* no kwarg */
3311 VALUE *const klocals = argv + kw_param->bits_start - kw_param->num;
3312 args_setup_kw_parameters(ec, iseq, vm_cc_cme(cc), NULL, 0, NULL, klocals);
3313
3314 if (klocals[kw_param->num] == INT2FIX(0)) {
3315 /* copy from default_values */
3316 CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_nokwarg,
3317 vm_call_cacheable(ci, cc));
3318 }
3319
3320 return 0;
3321 }
3322 }
3323 }
3324
3325 // Called iseq is using ... param
3326 // def foo(...) # <- iseq for foo will have "forwardable"
3327 //
3328 // We want to set the `...` local to the caller's CI
3329 // foo(1, 2) # <- the ci for this should end up as `...`
3330 //
3331 // So hopefully the stack looks like:
3332 //
3333 // => 1
3334 // => 2
3335 // => *
3336 // => **
3337 // => &
3338 // => ... # <- points at `foo`s CI
3339 // => cref_or_me
3340 // => specval
3341 // => type
3342 //
3343 if (ISEQ_BODY(iseq)->param.flags.forwardable) {
3344 bool can_fastpath = true;
3345
3346 if ((vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
3347 struct rb_forwarding_call_data * forward_cd = (struct rb_forwarding_call_data *)calling->cd;
3348 if (vm_ci_argc(ci) != vm_ci_argc(forward_cd->caller_ci)) {
3349 ci = vm_ci_new_runtime(
3350 vm_ci_mid(ci),
3351 vm_ci_flag(ci),
3352 vm_ci_argc(ci),
3353 vm_ci_kwarg(ci));
3354 }
3355 else {
3356 ci = forward_cd->caller_ci;
3357 }
3358 can_fastpath = false;
3359 }
3360 // C functions calling iseqs will stack allocate a CI,
3361 // so we need to convert it to heap allocated
3362 if (!vm_ci_markable(ci)) {
3363 ci = vm_ci_new_runtime(
3364 vm_ci_mid(ci),
3365 vm_ci_flag(ci),
3366 vm_ci_argc(ci),
3367 vm_ci_kwarg(ci));
3368 can_fastpath = false;
3369 }
3370 argv[param_size - 1] = (VALUE)ci;
3371 CC_SET_FASTPATH(cc, vm_call_iseq_forwardable, can_fastpath);
3372 return 0;
3373 }
3374
3375 return setup_parameters_complex(ec, iseq, calling, ci, argv, arg_setup_method);
3376}
3377
3378static void
3379vm_adjust_stack_forwarding(const struct rb_execution_context_struct *ec, struct rb_control_frame_struct *cfp, int argc, VALUE splat)
3380{
3381 // This case is when the caller is using a ... parameter.
3382 // For example `bar(...)`. The call info will have VM_CALL_FORWARDING
3383 // In this case the caller's caller's CI will be on the stack.
3384 //
3385 // For example:
3386 //
3387 // def bar(a, b); a + b; end
3388 // def foo(...); bar(...); end
3389 // foo(1, 2) # <- this CI will be on the stack when we call `bar(...)`
3390 //
3391 // Stack layout will be:
3392 //
3393 // > 1
3394 // > 2
3395 // > CI for foo(1, 2)
3396 // > cref_or_me
3397 // > specval
3398 // > type
3399 // > receiver
3400 // > CI for foo(1, 2), via `getlocal ...`
3401 // > ( SP points here )
3402 const VALUE * lep = VM_CF_LEP(cfp);
3403
3404 const rb_iseq_t *iseq;
3405
3406 // If we're in an escaped environment (lambda for example), get the iseq
3407 // from the captured env.
3408 if (VM_ENV_FLAGS(lep, VM_ENV_FLAG_ESCAPED)) {
3409 rb_env_t * env = (rb_env_t *)lep[VM_ENV_DATA_INDEX_ENV];
3410 iseq = env->iseq;
3411 }
3412 else { // Otherwise use the lep to find the caller
3413 iseq = rb_vm_search_cf_from_ep(ec, cfp, lep)->iseq;
3414 }
3415
3416 // Our local storage is below the args we need to copy
3417 int local_size = ISEQ_BODY(iseq)->local_table_size + argc;
3418
3419 const VALUE * from = lep - (local_size + VM_ENV_DATA_SIZE - 1); // 2 for EP values
3420 VALUE * to = cfp->sp - 1; // clobber the CI
3421
3422 if (RTEST(splat)) {
3423 to -= 1; // clobber the splat array
3424 CHECK_VM_STACK_OVERFLOW0(cfp, to, RARRAY_LEN(splat));
3425 MEMCPY(to, RARRAY_CONST_PTR(splat), VALUE, RARRAY_LEN(splat));
3426 to += RARRAY_LEN(splat);
3427 }
3428
3429 CHECK_VM_STACK_OVERFLOW0(cfp, to, argc);
3430 MEMCPY(to, from, VALUE, argc);
3431 cfp->sp = to + argc;
3432
3433 // Stack layout should now be:
3434 //
3435 // > 1
3436 // > 2
3437 // > CI for foo(1, 2)
3438 // > cref_or_me
3439 // > specval
3440 // > type
3441 // > receiver
3442 // > 1
3443 // > 2
3444 // > ( SP points here )
3445}
3446
3447static VALUE
3448vm_call_iseq_setup(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
3449{
3450 RB_DEBUG_COUNTER_INC(ccf_iseq_setup);
3451
3452 const struct rb_callcache *cc = calling->cc;
3453 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3454 int param_size = ISEQ_BODY(iseq)->param.size;
3455 int local_size = ISEQ_BODY(iseq)->local_table_size;
3456
3457 RUBY_ASSERT(!ISEQ_BODY(iseq)->param.flags.forwardable);
3458
3459 const int opt_pc = vm_callee_setup_arg(ec, calling, iseq, cfp->sp - calling->argc, param_size, local_size);
3460 return vm_call_iseq_setup_2(ec, cfp, calling, opt_pc, param_size, local_size);
3461}
3462
3463static VALUE
3464vm_call_iseq_fwd_setup(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
3465{
3466 RB_DEBUG_COUNTER_INC(ccf_iseq_setup);
3467
3468 const struct rb_callcache *cc = calling->cc;
3469 const rb_iseq_t *iseq = def_iseq_ptr(vm_cc_cme(cc)->def);
3470 int param_size = ISEQ_BODY(iseq)->param.size;
3471 int local_size = ISEQ_BODY(iseq)->local_table_size;
3472
3473 RUBY_ASSERT(ISEQ_BODY(iseq)->param.flags.forwardable);
3474
3475 // Setting up local size and param size
3476 local_size = local_size + vm_ci_argc(calling->cd->ci);
3477 param_size = param_size + vm_ci_argc(calling->cd->ci);
3478
3479 const int opt_pc = vm_callee_setup_arg(ec, calling, iseq, cfp->sp - calling->argc, param_size, local_size);
3480 return vm_call_iseq_setup_2(ec, cfp, calling, opt_pc, param_size, local_size);
3481}
3482
3483static inline VALUE
3484vm_call_iseq_setup_2(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling,
3485 int opt_pc, int param_size, int local_size)
3486{
3487 const struct rb_callinfo *ci = calling->cd->ci;
3488 const struct rb_callcache *cc = calling->cc;
3489
3490 if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {
3491 return vm_call_iseq_setup_normal(ec, cfp, calling, vm_cc_cme(cc), opt_pc, param_size, local_size);
3492 }
3493 else {
3494 return vm_call_iseq_setup_tailcall(ec, cfp, calling, opt_pc);
3495 }
3496}
3497
3498static inline VALUE
3499vm_call_iseq_setup_normal(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, const rb_callable_method_entry_t *me,
3500 int opt_pc, int param_size, int local_size)
3501{
3502 const rb_iseq_t *iseq = def_iseq_ptr(me->def);
3503 VALUE *argv = cfp->sp - calling->argc;
3504 VALUE *sp = argv + param_size;
3505 cfp->sp = argv - 1 /* recv */;
3506
3507 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL, calling->recv,
3508 calling->block_handler, (VALUE)me,
3509 ISEQ_BODY(iseq)->iseq_encoded + opt_pc, sp,
3510 local_size - param_size,
3511 ISEQ_BODY(iseq)->stack_max);
3512 return Qundef;
3513}
3514
3515static inline VALUE
3516vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, int opt_pc)
3517{
3518 const struct rb_callcache *cc = calling->cc;
3519 unsigned int i;
3520 VALUE *argv = cfp->sp - calling->argc;
3521 const rb_callable_method_entry_t *me = vm_cc_cme(cc);
3522 const rb_iseq_t *iseq = def_iseq_ptr(me->def);
3523 VALUE *src_argv = argv;
3524 VALUE *sp_orig, *sp;
3525 VALUE finish_flag = VM_FRAME_FINISHED_P(cfp) ? VM_FRAME_FLAG_FINISH : 0;
3526
3527 if (VM_BH_FROM_CFP_P(calling->block_handler, cfp)) {
3528 struct rb_captured_block *dst_captured = VM_CFP_TO_CAPTURED_BLOCK(RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp));
3529 const struct rb_captured_block *src_captured = VM_BH_TO_CAPT_BLOCK(calling->block_handler);
3530 dst_captured->code.val = src_captured->code.val;
3531 if (VM_BH_ISEQ_BLOCK_P(calling->block_handler)) {
3532 calling->block_handler = VM_BH_FROM_ISEQ_BLOCK(dst_captured);
3533 }
3534 else {
3535 calling->block_handler = VM_BH_FROM_IFUNC_BLOCK(dst_captured);
3536 }
3537 }
3538
3539 vm_pop_frame(ec, cfp, cfp->ep);
3540 cfp = ec->cfp;
3541
3542 sp_orig = sp = cfp->sp;
3543
3544 /* push self */
3545 sp[0] = calling->recv;
3546 sp++;
3547
3548 /* copy arguments */
3549 for (i=0; i < ISEQ_BODY(iseq)->param.size; i++) {
3550 *sp++ = src_argv[i];
3551 }
3552
3553 vm_push_frame(ec, iseq, VM_FRAME_MAGIC_METHOD | VM_ENV_FLAG_LOCAL | finish_flag,
3554 calling->recv, calling->block_handler, (VALUE)me,
3555 ISEQ_BODY(iseq)->iseq_encoded + opt_pc, sp,
3556 ISEQ_BODY(iseq)->local_table_size - ISEQ_BODY(iseq)->param.size,
3557 ISEQ_BODY(iseq)->stack_max);
3558
3559 cfp->sp = sp_orig;
3560
3561 return Qundef;
3562}
3563
3564static void
3565ractor_unsafe_check(void)
3566{
3567 if (!rb_ractor_main_p()) {
3568 rb_raise(rb_eRactorUnsafeError, "ractor unsafe method called from not main ractor");
3569 }
3570}
3571
3572static VALUE
3573call_cfunc_m2(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3574{
3575 ractor_unsafe_check();
3576 VALUE(*f)(VALUE, VALUE) = (VALUE(*)(VALUE, VALUE))func;
3577 return (*f)(recv, rb_ary_new4(argc, argv));
3578}
3579
3580static VALUE
3581call_cfunc_m1(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3582{
3583 ractor_unsafe_check();
3584 VALUE(*f)(int, const VALUE *, VALUE) = (VALUE(*)(int, const VALUE *, VALUE))func;
3585 return (*f)(argc, argv, recv);
3586}
3587
3588static VALUE
3589call_cfunc_0(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3590{
3591 ractor_unsafe_check();
3592 VALUE(*f)(VALUE) = (VALUE(*)(VALUE))func;
3593 return (*f)(recv);
3594}
3595
3596static VALUE
3597call_cfunc_1(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3598{
3599 ractor_unsafe_check();
3600 VALUE(*f)(VALUE, VALUE) = (VALUE(*)(VALUE, VALUE))func;
3601 return (*f)(recv, argv[0]);
3602}
3603
3604static VALUE
3605call_cfunc_2(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3606{
3607 ractor_unsafe_check();
3608 VALUE(*f)(VALUE, VALUE, VALUE) = (VALUE(*)(VALUE, VALUE, VALUE))func;
3609 return (*f)(recv, argv[0], argv[1]);
3610}
3611
3612static VALUE
3613call_cfunc_3(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3614{
3615 ractor_unsafe_check();
3616 VALUE(*f)(VALUE, VALUE, VALUE, VALUE) = (VALUE(*)(VALUE, VALUE, VALUE, VALUE))func;
3617 return (*f)(recv, argv[0], argv[1], argv[2]);
3618}
3619
3620static VALUE
3621call_cfunc_4(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3622{
3623 ractor_unsafe_check();
3624 VALUE(*f)(VALUE, VALUE, VALUE, VALUE, VALUE) = (VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE))func;
3625 return (*f)(recv, argv[0], argv[1], argv[2], argv[3]);
3626}
3627
3628static VALUE
3629call_cfunc_5(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3630{
3631 ractor_unsafe_check();
3632 VALUE(*f)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE) = (VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE))func;
3633 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4]);
3634}
3635
3636static VALUE
3637call_cfunc_6(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3638{
3639 ractor_unsafe_check();
3641 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
3642}
3643
3644static VALUE
3645call_cfunc_7(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3646{
3647 ractor_unsafe_check();
3649 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
3650}
3651
3652static VALUE
3653call_cfunc_8(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3654{
3655 ractor_unsafe_check();
3657 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
3658}
3659
3660static VALUE
3661call_cfunc_9(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3662{
3663 ractor_unsafe_check();
3665 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
3666}
3667
3668static VALUE
3669call_cfunc_10(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3670{
3671 ractor_unsafe_check();
3673 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]);
3674}
3675
3676static VALUE
3677call_cfunc_11(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3678{
3679 ractor_unsafe_check();
3681 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]);
3682}
3683
3684static VALUE
3685call_cfunc_12(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3686{
3687 ractor_unsafe_check();
3689 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]);
3690}
3691
3692static VALUE
3693call_cfunc_13(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3694{
3695 ractor_unsafe_check();
3697 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12]);
3698}
3699
3700static VALUE
3701call_cfunc_14(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3702{
3703 ractor_unsafe_check();
3705 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13]);
3706}
3707
3708static VALUE
3709call_cfunc_15(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3710{
3711 ractor_unsafe_check();
3713 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14]);
3714}
3715
3716static VALUE
3717ractor_safe_call_cfunc_m2(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3718{
3719 VALUE(*f)(VALUE, VALUE) = (VALUE(*)(VALUE, VALUE))func;
3720 return (*f)(recv, rb_ary_new4(argc, argv));
3721}
3722
3723static VALUE
3724ractor_safe_call_cfunc_m1(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3725{
3726 VALUE(*f)(int, const VALUE *, VALUE) = (VALUE(*)(int, const VALUE *, VALUE))func;
3727 return (*f)(argc, argv, recv);
3728}
3729
3730static VALUE
3731ractor_safe_call_cfunc_0(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3732{
3733 VALUE(*f)(VALUE) = (VALUE(*)(VALUE))func;
3734 return (*f)(recv);
3735}
3736
3737static VALUE
3738ractor_safe_call_cfunc_1(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3739{
3740 VALUE(*f)(VALUE, VALUE) = (VALUE(*)(VALUE, VALUE))func;
3741 return (*f)(recv, argv[0]);
3742}
3743
3744static VALUE
3745ractor_safe_call_cfunc_2(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3746{
3747 VALUE(*f)(VALUE, VALUE, VALUE) = (VALUE(*)(VALUE, VALUE, VALUE))func;
3748 return (*f)(recv, argv[0], argv[1]);
3749}
3750
3751static VALUE
3752ractor_safe_call_cfunc_3(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3753{
3754 VALUE(*f)(VALUE, VALUE, VALUE, VALUE) = (VALUE(*)(VALUE, VALUE, VALUE, VALUE))func;
3755 return (*f)(recv, argv[0], argv[1], argv[2]);
3756}
3757
3758static VALUE
3759ractor_safe_call_cfunc_4(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3760{
3761 VALUE(*f)(VALUE, VALUE, VALUE, VALUE, VALUE) = (VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE))func;
3762 return (*f)(recv, argv[0], argv[1], argv[2], argv[3]);
3763}
3764
3765static VALUE
3766ractor_safe_call_cfunc_5(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3767{
3768 VALUE(*f)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE) = (VALUE(*)(VALUE, VALUE, VALUE, VALUE, VALUE, VALUE))func;
3769 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4]);
3770}
3771
3772static VALUE
3773ractor_safe_call_cfunc_6(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3774{
3776 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
3777}
3778
3779static VALUE
3780ractor_safe_call_cfunc_7(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3781{
3783 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
3784}
3785
3786static VALUE
3787ractor_safe_call_cfunc_8(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3788{
3790 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
3791}
3792
3793static VALUE
3794ractor_safe_call_cfunc_9(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3795{
3797 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
3798}
3799
3800static VALUE
3801ractor_safe_call_cfunc_10(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3802{
3804 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]);
3805}
3806
3807static VALUE
3808ractor_safe_call_cfunc_11(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3809{
3811 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]);
3812}
3813
3814static VALUE
3815ractor_safe_call_cfunc_12(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3816{
3818 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]);
3819}
3820
3821static VALUE
3822ractor_safe_call_cfunc_13(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3823{
3825 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12]);
3826}
3827
3828static VALUE
3829ractor_safe_call_cfunc_14(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3830{
3832 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13]);
3833}
3834
3835static VALUE
3836ractor_safe_call_cfunc_15(VALUE recv, int argc, const VALUE *argv, VALUE (*func)(ANYARGS))
3837{
3839 return (*f)(recv, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14]);
3840}
3841
3842static inline int
3843vm_cfp_consistent_p(rb_execution_context_t *ec, const rb_control_frame_t *reg_cfp)
3844{
3845 const int ov_flags = RAISED_STACKOVERFLOW;
3846 if (LIKELY(reg_cfp == ec->cfp + 1)) return TRUE;
3847 if (rb_ec_raised_p(ec, ov_flags)) {
3848 rb_ec_raised_reset(ec, ov_flags);
3849 return TRUE;
3850 }
3851 return FALSE;
3852}
3853
3854#define CHECK_CFP_CONSISTENCY(func) \
3855 (LIKELY(vm_cfp_consistent_p(ec, reg_cfp)) ? (void)0 : \
3856 rb_bug(func ": cfp consistency error (%p, %p)", (void *)reg_cfp, (void *)(ec->cfp+1)))
3857
3858static inline
3859const rb_method_cfunc_t *
3860vm_method_cfunc_entry(const rb_callable_method_entry_t *me)
3861{
3862#if VM_DEBUG_VERIFY_METHOD_CACHE
3863 switch (me->def->type) {
3864 case VM_METHOD_TYPE_CFUNC:
3865 case VM_METHOD_TYPE_NOTIMPLEMENTED:
3866 break;
3867# define METHOD_BUG(t) case VM_METHOD_TYPE_##t: rb_bug("wrong method type: " #t)
3868 METHOD_BUG(ISEQ);
3869 METHOD_BUG(ATTRSET);
3870 METHOD_BUG(IVAR);
3871 METHOD_BUG(BMETHOD);
3872 METHOD_BUG(ZSUPER);
3873 METHOD_BUG(UNDEF);
3874 METHOD_BUG(OPTIMIZED);
3875 METHOD_BUG(MISSING);
3876 METHOD_BUG(REFINED);
3877 METHOD_BUG(ALIAS);
3878# undef METHOD_BUG
3879 default:
3880 rb_bug("wrong method type: %d", me->def->type);
3881 }
3882#endif
3883 return UNALIGNED_MEMBER_PTR(me->def, body.cfunc);
3884}
3885
3886static VALUE
3887vm_call_cfunc_with_frame_(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling,
3888 int argc, VALUE *argv, VALUE *stack_bottom)
3889{
3890 RB_DEBUG_COUNTER_INC(ccf_cfunc_with_frame);
3891 const struct rb_callinfo *ci = calling->cd->ci;
3892 const struct rb_callcache *cc = calling->cc;
3893 VALUE val;
3894 const rb_callable_method_entry_t *me = vm_cc_cme(cc);
3895 const rb_method_cfunc_t *cfunc = vm_method_cfunc_entry(me);
3896
3897 VALUE recv = calling->recv;
3898 VALUE block_handler = calling->block_handler;
3899 VALUE frame_type = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
3900
3901 if (UNLIKELY(calling->kw_splat)) {
3902 frame_type |= VM_FRAME_FLAG_CFRAME_KW;
3903 }
3904
3905 VM_ASSERT(reg_cfp == ec->cfp);
3906
3907 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, me->owner, me->def->original_id);
3908 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_CALL, recv, me->def->original_id, vm_ci_mid(ci), me->owner, Qundef);
3909
3910 vm_push_frame(ec, NULL, frame_type, recv,
3911 block_handler, (VALUE)me,
3912 0, ec->cfp->sp, 0, 0);
3913
3914 int len = cfunc->argc;
3915 if (len >= 0) rb_check_arity(argc, len, len);
3916
3917 reg_cfp->sp = stack_bottom;
3918 val = (*cfunc->invoker)(recv, argc, argv, cfunc->func);
3919
3920 CHECK_CFP_CONSISTENCY("vm_call_cfunc");
3921
3922 rb_vm_pop_frame(ec);
3923
3924 VM_ASSERT(ec->cfp->sp == stack_bottom);
3925
3926 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, recv, me->def->original_id, vm_ci_mid(ci), me->owner, val);
3927 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, me->owner, me->def->original_id);
3928
3929 return val;
3930}
3931
3932// Push a C method frame for a given cme. This is called when JIT code skipped
3933// pushing a frame but the C method reached a point where a frame is needed.
3934void
3935rb_vm_push_cfunc_frame(const rb_callable_method_entry_t *cme, int recv_idx)
3936{
3937 VM_ASSERT(cme->def->type == VM_METHOD_TYPE_CFUNC);
3938 rb_execution_context_t *ec = GET_EC();
3939 VALUE *sp = ec->cfp->sp;
3940 VALUE recv = *(sp - recv_idx - 1);
3941 VALUE frame_type = VM_FRAME_MAGIC_CFUNC | VM_FRAME_FLAG_CFRAME | VM_ENV_FLAG_LOCAL;
3942 VALUE block_handler = VM_BLOCK_HANDLER_NONE;
3943#if VM_CHECK_MODE > 0
3944 // Clean up the stack canary since we're about to satisfy the "leaf or lazy push" assumption
3945 *(GET_EC()->cfp->sp) = Qfalse;
3946#endif
3947 vm_push_frame(ec, NULL, frame_type, recv, block_handler, (VALUE)cme, 0, ec->cfp->sp, 0, 0);
3948}
3949
3950// If true, cc->call needs to include `CALLER_SETUP_ARG` (i.e. can't be skipped in fastpath)
3951bool
3952rb_splat_or_kwargs_p(const struct rb_callinfo *restrict ci)
3953{
3954 return IS_ARGS_SPLAT(ci) || IS_ARGS_KW_OR_KW_SPLAT(ci);
3955}
3956
3957static VALUE
3958vm_call_cfunc_with_frame(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
3959{
3960 int argc = calling->argc;
3961 VALUE *stack_bottom = reg_cfp->sp - argc - 1;
3962 VALUE *argv = &stack_bottom[1];
3963
3964 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, argv, stack_bottom);
3965}
3966
3967static VALUE
3968vm_call_cfunc_other(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
3969{
3970 const struct rb_callinfo *ci = calling->cd->ci;
3971 RB_DEBUG_COUNTER_INC(ccf_cfunc_other);
3972
3973 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV_KEEP_KWSPLAT);
3974 VALUE argv_ary;
3975 if (UNLIKELY(argv_ary = calling->heap_argv)) {
3976 VM_ASSERT(!IS_ARGS_KEYWORD(ci));
3977 int argc = RARRAY_LENINT(argv_ary);
3978 VALUE *argv = (VALUE *)RARRAY_CONST_PTR(argv_ary);
3979 VALUE *stack_bottom = reg_cfp->sp - 2;
3980
3981 VM_ASSERT(calling->argc == 1);
3982 VM_ASSERT(RB_TYPE_P(argv_ary, T_ARRAY));
3983 VM_ASSERT(RBASIC_CLASS(argv_ary) == 0); // hidden ary
3984
3985 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, argv, stack_bottom);
3986 }
3987 else {
3988 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_with_frame, !rb_splat_or_kwargs_p(ci) && !calling->kw_splat && !(vm_ci_flag(ci) & VM_CALL_FORWARDING));
3989
3990 return vm_call_cfunc_with_frame(ec, reg_cfp, calling);
3991 }
3992}
3993
3994static inline VALUE
3995vm_call_cfunc_array_argv(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling, int stack_offset, int argc_offset)
3996{
3997 VALUE argv_ary = reg_cfp->sp[-1 - stack_offset];
3998 int argc = RARRAY_LENINT(argv_ary) - argc_offset;
3999
4000 if (UNLIKELY(argc > VM_ARGC_STACK_MAX)) {
4001 return vm_call_cfunc_other(ec, reg_cfp, calling);
4002 }
4003
4004 VALUE *argv = (VALUE *)RARRAY_CONST_PTR(argv_ary);
4005 calling->kw_splat = 0;
4006 int i;
4007 VALUE *stack_bottom = reg_cfp->sp - 2 - stack_offset;
4008 VALUE *sp = stack_bottom;
4009 CHECK_VM_STACK_OVERFLOW(reg_cfp, argc);
4010 for(i = 0; i < argc; i++) {
4011 *++sp = argv[i];
4012 }
4013 reg_cfp->sp = sp+1;
4014
4015 return vm_call_cfunc_with_frame_(ec, reg_cfp, calling, argc, stack_bottom+1, stack_bottom);
4016}
4017
4018static inline VALUE
4019vm_call_cfunc_only_splat(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4020{
4021 RB_DEBUG_COUNTER_INC(ccf_cfunc_only_splat);
4022 VALUE argv_ary = reg_cfp->sp[-1];
4023 int argc = RARRAY_LENINT(argv_ary);
4024 VALUE *argv = (VALUE *)RARRAY_CONST_PTR(argv_ary);
4025 VALUE last_hash;
4026 int argc_offset = 0;
4027
4028 if (UNLIKELY(argc > 0 &&
4029 RB_TYPE_P((last_hash = argv[argc-1]), T_HASH) &&
4030 (((struct RHash *)last_hash)->basic.flags & RHASH_PASS_AS_KEYWORDS))) {
4031 if (!RHASH_EMPTY_P(last_hash)) {
4032 return vm_call_cfunc_other(ec, reg_cfp, calling);
4033 }
4034 argc_offset++;
4035 }
4036 return vm_call_cfunc_array_argv(ec, reg_cfp, calling, 0, argc_offset);
4037}
4038
4039static inline VALUE
4040vm_call_cfunc_only_splat_kw(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4041{
4042 RB_DEBUG_COUNTER_INC(ccf_cfunc_only_splat_kw);
4043 VALUE keyword_hash = reg_cfp->sp[-1];
4044
4045 if (keyword_hash == Qnil || (RB_TYPE_P(keyword_hash, T_HASH) && RHASH_EMPTY_P(keyword_hash))) {
4046 return vm_call_cfunc_array_argv(ec, reg_cfp, calling, 1, 0);
4047 }
4048
4049 return vm_call_cfunc_other(ec, reg_cfp, calling);
4050}
4051
4052static VALUE
4053vm_call_cfunc(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4054{
4055 const struct rb_callinfo *ci = calling->cd->ci;
4056 RB_DEBUG_COUNTER_INC(ccf_cfunc);
4057
4058 if (IS_ARGS_SPLAT(ci) && !(vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
4059 if (!IS_ARGS_KW_SPLAT(ci) && vm_ci_argc(ci) == 1) {
4060 // f(*a)
4061 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_only_splat, TRUE);
4062 return vm_call_cfunc_only_splat(ec, reg_cfp, calling);
4063 }
4064 if (IS_ARGS_KW_SPLAT(ci) && vm_ci_argc(ci) == 2) {
4065 // f(*a, **kw)
4066 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_only_splat_kw, TRUE);
4067 return vm_call_cfunc_only_splat_kw(ec, reg_cfp, calling);
4068 }
4069 }
4070
4071 CC_SET_FASTPATH(calling->cc, vm_call_cfunc_other, TRUE);
4072 return vm_call_cfunc_other(ec, reg_cfp, calling);
4073}
4074
4075static VALUE
4076vm_call_ivar(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4077{
4078 const struct rb_callcache *cc = calling->cc;
4079 RB_DEBUG_COUNTER_INC(ccf_ivar);
4080 cfp->sp -= 1;
4081 VALUE ivar = vm_getivar(calling->recv, vm_cc_cme(cc)->def->body.attr.id, NULL, NULL, cc, TRUE, Qnil);
4082 return ivar;
4083}
4084
4085static VALUE
4086vm_call_attrset_direct(rb_execution_context_t *ec, rb_control_frame_t *cfp, const struct rb_callcache *cc, VALUE obj)
4087{
4088 RB_DEBUG_COUNTER_INC(ccf_attrset);
4089 VALUE val = *(cfp->sp - 1);
4090 cfp->sp -= 2;
4091 attr_index_t index;
4092 shape_id_t dest_shape_id;
4093 vm_cc_atomic_shape_and_index(cc, &dest_shape_id, &index);
4094 ID id = vm_cc_cme(cc)->def->body.attr.id;
4095 rb_check_frozen(obj);
4096 VALUE res = vm_setivar(obj, id, val, dest_shape_id, index);
4097 if (UNDEF_P(res)) {
4098 switch (BUILTIN_TYPE(obj)) {
4099 case T_OBJECT:
4100 break;
4101 case T_CLASS:
4102 case T_MODULE:
4103 {
4104 res = vm_setivar_class(obj, id, val, dest_shape_id, index);
4105 if (!UNDEF_P(res)) {
4106 return res;
4107 }
4108 }
4109 break;
4110 default:
4111 {
4112 res = vm_setivar_default(obj, id, val, dest_shape_id, index);
4113 if (!UNDEF_P(res)) {
4114 return res;
4115 }
4116 }
4117 }
4118 res = vm_setivar_slowpath_attr(obj, id, val, cc);
4119 }
4120 return res;
4121}
4122
4123static VALUE
4124vm_call_attrset(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4125{
4126 return vm_call_attrset_direct(ec, cfp, calling->cc, calling->recv);
4127}
4128
4129static inline VALUE
4130vm_call_bmethod_body(rb_execution_context_t *ec, struct rb_calling_info *calling, const VALUE *argv)
4131{
4132 rb_proc_t *proc;
4133 VALUE val;
4134 const struct rb_callcache *cc = calling->cc;
4135 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4136 VALUE procv = cme->def->body.bmethod.proc;
4137
4138 if (!RB_OBJ_SHAREABLE_P(procv) &&
4139 cme->def->body.bmethod.defined_ractor_id != rb_ec_ractor_id(ec)) {
4140 rb_raise(rb_eRuntimeError, "defined with an un-shareable Proc in a different Ractor");
4141 }
4142
4143 /* control block frame */
4144 GetProcPtr(procv, proc);
4145 val = vm_invoke_bmethod(ec, proc, calling->recv, CALLING_ARGC(calling), argv, calling->kw_splat, calling->block_handler, vm_cc_cme(cc));
4146
4147 return val;
4148}
4149
4150static int vm_callee_setup_block_arg(rb_execution_context_t *ec, struct rb_calling_info *calling, const struct rb_callinfo *ci, const rb_iseq_t *iseq, VALUE *argv, const enum arg_setup_type arg_setup_type);
4151
4152static VALUE
4153vm_call_iseq_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4154{
4155 RB_DEBUG_COUNTER_INC(ccf_iseq_bmethod);
4156
4157 const struct rb_callcache *cc = calling->cc;
4158 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4159 VALUE procv = cme->def->body.bmethod.proc;
4160
4161 if (!RB_OBJ_SHAREABLE_P(procv) &&
4162 cme->def->body.bmethod.defined_ractor_id != rb_ec_ractor_id(ec)) {
4163 rb_raise(rb_eRuntimeError, "defined with an un-shareable Proc in a different Ractor");
4164 }
4165
4166 rb_proc_t *proc;
4167 GetProcPtr(procv, proc);
4168 const struct rb_block *block = &proc->block;
4169
4170 while (vm_block_type(block) == block_type_proc) {
4171 block = vm_proc_block(block->as.proc);
4172 }
4173 VM_ASSERT(vm_block_type(block) == block_type_iseq);
4174
4175 const struct rb_captured_block *captured = &block->as.captured;
4176 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
4177 VALUE * const argv = cfp->sp - calling->argc;
4178 const int arg_size = ISEQ_BODY(iseq)->param.size;
4179
4180 int opt_pc;
4181 if (vm_ci_flag(calling->cd->ci) & VM_CALL_ARGS_SIMPLE) {
4182 opt_pc = vm_callee_setup_block_arg(ec, calling, calling->cd->ci, iseq, argv, arg_setup_method);
4183 }
4184 else {
4185 opt_pc = setup_parameters_complex(ec, iseq, calling, calling->cd->ci, argv, arg_setup_method);
4186 }
4187
4188 cfp->sp = argv - 1; // -1 for the receiver
4189
4190 vm_push_frame(ec, iseq,
4191 VM_FRAME_MAGIC_BLOCK | VM_FRAME_FLAG_BMETHOD | VM_FRAME_FLAG_LAMBDA,
4192 calling->recv,
4193 VM_GUARDED_PREV_EP(captured->ep),
4194 (VALUE)cme,
4195 ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
4196 argv + arg_size,
4197 ISEQ_BODY(iseq)->local_table_size - arg_size,
4198 ISEQ_BODY(iseq)->stack_max);
4199
4200 return Qundef;
4201}
4202
4203static VALUE
4204vm_call_noniseq_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4205{
4206 RB_DEBUG_COUNTER_INC(ccf_noniseq_bmethod);
4207
4208 VALUE *argv;
4209 int argc;
4210 CALLER_SETUP_ARG(cfp, calling, calling->cd->ci, ALLOW_HEAP_ARGV);
4211 if (UNLIKELY(calling->heap_argv)) {
4212 argv = RARRAY_PTR(calling->heap_argv);
4213 cfp->sp -= 2;
4214 }
4215 else {
4216 argc = calling->argc;
4217 argv = ALLOCA_N(VALUE, argc);
4218 MEMCPY(argv, cfp->sp - argc, VALUE, argc);
4219 cfp->sp += - argc - 1;
4220 }
4221
4222 return vm_call_bmethod_body(ec, calling, argv);
4223}
4224
4225static VALUE
4226vm_call_bmethod(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4227{
4228 RB_DEBUG_COUNTER_INC(ccf_bmethod);
4229
4230 const struct rb_callcache *cc = calling->cc;
4231 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4232 VALUE procv = cme->def->body.bmethod.proc;
4233 rb_proc_t *proc;
4234 GetProcPtr(procv, proc);
4235 const struct rb_block *block = &proc->block;
4236
4237 while (vm_block_type(block) == block_type_proc) {
4238 block = vm_proc_block(block->as.proc);
4239 }
4240 if (vm_block_type(block) == block_type_iseq) {
4241 CC_SET_FASTPATH(cc, vm_call_iseq_bmethod, TRUE);
4242 return vm_call_iseq_bmethod(ec, cfp, calling);
4243 }
4244
4245 CC_SET_FASTPATH(cc, vm_call_noniseq_bmethod, TRUE);
4246 return vm_call_noniseq_bmethod(ec, cfp, calling);
4247}
4248
4249VALUE
4250rb_find_defined_class_by_owner(VALUE current_class, VALUE target_owner)
4251{
4252 VALUE klass = current_class;
4253
4254 /* for prepended Module, then start from cover class */
4255 if (RB_TYPE_P(klass, T_ICLASS) && RICLASS_IS_ORIGIN_P(klass) &&
4256 RB_TYPE_P(RBASIC_CLASS(klass), T_CLASS)) {
4257 klass = RBASIC_CLASS(klass);
4258 }
4259
4260 while (RTEST(klass)) {
4261 VALUE owner = RB_TYPE_P(klass, T_ICLASS) ? RBASIC_CLASS(klass) : klass;
4262 if (owner == target_owner) {
4263 return klass;
4264 }
4265 klass = RCLASS_SUPER(klass);
4266 }
4267
4268 return current_class; /* maybe module function */
4269}
4270
4271static const rb_callable_method_entry_t *
4272aliased_callable_method_entry(const rb_callable_method_entry_t *me)
4273{
4274 const rb_method_entry_t *orig_me = me->def->body.alias.original_me;
4275 const rb_callable_method_entry_t *cme;
4276
4277 if (orig_me->defined_class == 0) {
4278 VALUE defined_class = rb_find_defined_class_by_owner(me->defined_class, orig_me->owner);
4279 VM_ASSERT_TYPE(orig_me->owner, T_MODULE);
4280 cme = rb_method_entry_complement_defined_class(orig_me, me->called_id, defined_class);
4281
4282 if (me->def->reference_count == 1) {
4283 RB_OBJ_WRITE(me, &me->def->body.alias.original_me, cme);
4284 }
4285 else {
4286 rb_method_definition_t *def =
4287 rb_method_definition_create(VM_METHOD_TYPE_ALIAS, me->def->original_id);
4288 rb_method_definition_set((rb_method_entry_t *)me, def, (void *)cme);
4289 }
4290 }
4291 else {
4292 cme = (const rb_callable_method_entry_t *)orig_me;
4293 }
4294
4295 VM_ASSERT(callable_method_entry_p(cme));
4296 return cme;
4297}
4298
4299const rb_callable_method_entry_t *
4300rb_aliased_callable_method_entry(const rb_callable_method_entry_t *me)
4301{
4302 return aliased_callable_method_entry(me);
4303}
4304
4305static VALUE
4306vm_call_alias(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4307{
4308 calling->cc = &VM_CC_ON_STACK(Qundef,
4309 vm_call_general,
4310 {{0}},
4311 aliased_callable_method_entry(vm_cc_cme(calling->cc)));
4312
4313 return vm_call_method_each_type(ec, cfp, calling);
4314}
4315
4316static enum method_missing_reason
4317ci_missing_reason(const struct rb_callinfo *ci)
4318{
4319 enum method_missing_reason stat = MISSING_NOENTRY;
4320 if (vm_ci_flag(ci) & VM_CALL_VCALL && !(vm_ci_flag(ci) & VM_CALL_FORWARDING)) stat |= MISSING_VCALL;
4321 if (vm_ci_flag(ci) & VM_CALL_FCALL) stat |= MISSING_FCALL;
4322 if (vm_ci_flag(ci) & VM_CALL_SUPER) stat |= MISSING_SUPER;
4323 return stat;
4324}
4325
4326static VALUE vm_call_method_missing(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling);
4327
4328static VALUE
4329vm_call_symbol(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4330 struct rb_calling_info *calling, const struct rb_callinfo *ci, VALUE symbol, int flags)
4331{
4332 ASSUME(calling->argc >= 0);
4333
4334 enum method_missing_reason missing_reason = MISSING_NOENTRY;
4335 int argc = calling->argc;
4336 VALUE recv = calling->recv;
4337 VALUE klass = CLASS_OF(recv);
4338 ID mid = rb_check_id(&symbol);
4339 flags |= VM_CALL_OPT_SEND;
4340
4341 if (UNLIKELY(! mid)) {
4342 mid = idMethodMissing;
4343 missing_reason = ci_missing_reason(ci);
4344 ec->method_missing_reason = missing_reason;
4345
4346 VALUE argv_ary;
4347 if (UNLIKELY(argv_ary = calling->heap_argv)) {
4348 if (rb_method_basic_definition_p(klass, idMethodMissing)) {
4349 rb_ary_unshift(argv_ary, symbol);
4350
4351 /* Inadvertent symbol creation shall be forbidden, see [Feature #5112] */
4352 int priv = vm_ci_flag(ci) & (VM_CALL_FCALL | VM_CALL_VCALL);
4353 VALUE exc = rb_make_no_method_exception(
4354 rb_eNoMethodError, 0, recv, RARRAY_LENINT(argv_ary), RARRAY_CONST_PTR(argv_ary), priv);
4355
4356 rb_exc_raise(exc);
4357 }
4358 rb_ary_unshift(argv_ary, rb_str_intern(symbol));
4359 }
4360 else {
4361 /* E.g. when argc == 2
4362 *
4363 * | | | | TOPN
4364 * | | +------+
4365 * | | +---> | arg1 | 0
4366 * +------+ | +------+
4367 * | arg1 | -+ +-> | arg0 | 1
4368 * +------+ | +------+
4369 * | arg0 | ---+ | sym | 2
4370 * +------+ +------+
4371 * | recv | | recv | 3
4372 * --+------+--------+------+------
4373 */
4374 int i = argc;
4375 CHECK_VM_STACK_OVERFLOW(reg_cfp, 1);
4376 INC_SP(1);
4377 MEMMOVE(&TOPN(i - 1), &TOPN(i), VALUE, i);
4378 argc = ++calling->argc;
4379
4380 if (rb_method_basic_definition_p(klass, idMethodMissing)) {
4381 /* Inadvertent symbol creation shall be forbidden, see [Feature #5112] */
4382 TOPN(i) = symbol;
4383 int priv = vm_ci_flag(ci) & (VM_CALL_FCALL | VM_CALL_VCALL);
4384 const VALUE *argv = STACK_ADDR_FROM_TOP(argc);
4385 VALUE exc = rb_make_no_method_exception(
4386 rb_eNoMethodError, 0, recv, argc, argv, priv);
4387
4388 rb_exc_raise(exc);
4389 }
4390 else {
4391 TOPN(i) = rb_str_intern(symbol);
4392 }
4393 }
4394 }
4395
4396 struct rb_forwarding_call_data new_fcd = {
4397 .cd = {
4398 .ci = &VM_CI_ON_STACK(mid, flags, argc, vm_ci_kwarg(ci)),
4399 .cc = NULL,
4400 },
4401 .caller_ci = NULL,
4402 };
4403
4404 if (!(vm_ci_flag(ci) & VM_CALL_FORWARDING)) {
4405 calling->cd = &new_fcd.cd;
4406 }
4407 else {
4408 const struct rb_callinfo *caller_ci = ((struct rb_forwarding_call_data *)calling->cd)->caller_ci;
4409 VM_ASSERT((vm_ci_argc(caller_ci), 1));
4410 new_fcd.caller_ci = caller_ci;
4411 calling->cd = (struct rb_call_data *)&new_fcd;
4412 }
4413 calling->cc = &VM_CC_ON_STACK(klass,
4414 vm_call_general,
4415 { .method_missing_reason = missing_reason },
4416 rb_callable_method_entry_with_refinements(klass, mid, NULL));
4417
4418 if (flags & VM_CALL_FCALL) {
4419 return vm_call_method(ec, reg_cfp, calling);
4420 }
4421
4422 const struct rb_callcache *cc = calling->cc;
4423 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
4424
4425 if (vm_cc_cme(cc) != NULL) {
4426 switch (METHOD_ENTRY_VISI(vm_cc_cme(cc))) {
4427 case METHOD_VISI_PUBLIC: /* likely */
4428 return vm_call_method_each_type(ec, reg_cfp, calling);
4429 case METHOD_VISI_PRIVATE:
4430 vm_cc_method_missing_reason_set(cc, MISSING_PRIVATE);
4431 break;
4432 case METHOD_VISI_PROTECTED:
4433 vm_cc_method_missing_reason_set(cc, MISSING_PROTECTED);
4434 break;
4435 default:
4436 VM_UNREACHABLE(vm_call_method);
4437 }
4438 return vm_call_method_missing(ec, reg_cfp, calling);
4439 }
4440
4441 return vm_call_method_nome(ec, reg_cfp, calling);
4442}
4443
4444static VALUE
4445vm_call_opt_send0(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling, int flags)
4446{
4447 const struct rb_callinfo *ci = calling->cd->ci;
4448 int i;
4449 VALUE sym;
4450
4451 i = calling->argc - 1;
4452
4453 if (calling->argc == 0) {
4454 rb_raise(rb_eArgError, "no method name given");
4455 }
4456
4457 sym = TOPN(i);
4458 /* E.g. when i == 2
4459 *
4460 * | | | | TOPN
4461 * +------+ | |
4462 * | arg1 | ---+ | | 0
4463 * +------+ | +------+
4464 * | arg0 | -+ +-> | arg1 | 1
4465 * +------+ | +------+
4466 * | sym | +---> | arg0 | 2
4467 * +------+ +------+
4468 * | recv | | recv | 3
4469 * --+------+--------+------+------
4470 */
4471 /* shift arguments */
4472 if (i > 0) {
4473 MEMMOVE(&TOPN(i), &TOPN(i-1), VALUE, i);
4474 }
4475 calling->argc -= 1;
4476 DEC_SP(1);
4477
4478 return vm_call_symbol(ec, reg_cfp, calling, ci, sym, flags);
4479}
4480
4481static VALUE
4482vm_call_opt_send_complex(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4483{
4484 RB_DEBUG_COUNTER_INC(ccf_opt_send_complex);
4485 const struct rb_callinfo *ci = calling->cd->ci;
4486 int flags = VM_CALL_FCALL;
4487 VALUE sym;
4488
4489 VALUE argv_ary;
4490 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV);
4491 if (UNLIKELY(argv_ary = calling->heap_argv)) {
4492 sym = rb_ary_shift(argv_ary);
4493 flags |= VM_CALL_ARGS_SPLAT;
4494 if (calling->kw_splat) {
4495 VALUE last_hash = rb_ary_last(0, NULL, argv_ary);
4496 ((struct RHash *)last_hash)->basic.flags |= RHASH_PASS_AS_KEYWORDS;
4497 calling->kw_splat = 0;
4498 }
4499 return vm_call_symbol(ec, reg_cfp, calling, ci, sym, flags);
4500 }
4501
4502 if (calling->kw_splat) flags |= VM_CALL_KW_SPLAT;
4503 return vm_call_opt_send0(ec, reg_cfp, calling, flags);
4504}
4505
4506static VALUE
4507vm_call_opt_send_simple(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4508{
4509 RB_DEBUG_COUNTER_INC(ccf_opt_send_simple);
4510 return vm_call_opt_send0(ec, reg_cfp, calling, vm_ci_flag(calling->cd->ci) | VM_CALL_FCALL);
4511}
4512
4513static VALUE
4514vm_call_opt_send(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4515{
4516 RB_DEBUG_COUNTER_INC(ccf_opt_send);
4517
4518 const struct rb_callinfo *ci = calling->cd->ci;
4519 int flags = vm_ci_flag(ci);
4520
4521 if (UNLIKELY((flags & VM_CALL_FORWARDING) || (!(flags & VM_CALL_ARGS_SIMPLE) &&
4522 ((calling->argc == 1 && (flags & (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT))) ||
4523 (calling->argc == 2 && (flags & VM_CALL_ARGS_SPLAT) && (flags & VM_CALL_KW_SPLAT)) ||
4524 ((flags & VM_CALL_KWARG) && (vm_ci_kwarg(ci)->keyword_len == calling->argc)))))) {
4525 CC_SET_FASTPATH(calling->cc, vm_call_opt_send_complex, TRUE);
4526 return vm_call_opt_send_complex(ec, reg_cfp, calling);
4527 }
4528
4529 CC_SET_FASTPATH(calling->cc, vm_call_opt_send_simple, TRUE);
4530 return vm_call_opt_send_simple(ec, reg_cfp, calling);
4531}
4532
4533static VALUE
4534vm_call_method_missing_body(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling,
4535 const struct rb_callinfo *orig_ci, enum method_missing_reason reason)
4536{
4537 RB_DEBUG_COUNTER_INC(ccf_method_missing);
4538
4539 VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);
4540 unsigned int argc, flag;
4541
4542 flag = VM_CALL_FCALL | VM_CALL_OPT_SEND | vm_ci_flag(orig_ci);
4543 argc = ++calling->argc;
4544
4545 /* shift arguments: m(a, b, c) #=> method_missing(:m, a, b, c) */
4546 CHECK_VM_STACK_OVERFLOW(reg_cfp, 1);
4547 vm_check_canary(ec, reg_cfp->sp);
4548 if (argc > 1) {
4549 MEMMOVE(argv+1, argv, VALUE, argc-1);
4550 }
4551 argv[0] = ID2SYM(vm_ci_mid(orig_ci));
4552 INC_SP(1);
4553
4554 ec->method_missing_reason = reason;
4555
4556 struct rb_forwarding_call_data new_fcd = {
4557 .cd = {
4558 .ci = &VM_CI_ON_STACK(idMethodMissing, flag, argc, vm_ci_kwarg(orig_ci)),
4559 .cc = NULL,
4560 },
4561 .caller_ci = NULL,
4562 };
4563
4564 if (!(flag & VM_CALL_FORWARDING)) {
4565 calling->cd = &new_fcd.cd;
4566 }
4567 else {
4568 const struct rb_callinfo *caller_ci = ((struct rb_forwarding_call_data *)calling->cd)->caller_ci;
4569 VM_ASSERT((vm_ci_argc(caller_ci), 1));
4570 new_fcd.caller_ci = caller_ci;
4571 calling->cd = (struct rb_call_data *)&new_fcd;
4572 }
4573
4574 calling->cc = &VM_CC_ON_STACK(Qundef, vm_call_general, {{ 0 }},
4575 rb_callable_method_entry_without_refinements(CLASS_OF(calling->recv), idMethodMissing, NULL));
4576 return vm_call_method(ec, reg_cfp, calling);
4577}
4578
4579static VALUE
4580vm_call_method_missing(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4581{
4582 return vm_call_method_missing_body(ec, reg_cfp, calling, calling->cd->ci, vm_cc_cmethod_missing_reason(calling->cc));
4583}
4584
4585static const rb_callable_method_entry_t *refined_method_callable_without_refinement(const rb_callable_method_entry_t *me);
4586static VALUE
4587vm_call_zsuper(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, VALUE klass)
4588{
4589 klass = RCLASS_SUPER(klass);
4590
4591 const rb_callable_method_entry_t *cme = klass ? rb_callable_method_entry(klass, vm_ci_mid(calling->cd->ci)) : NULL;
4592 if (cme == NULL) {
4593 return vm_call_method_nome(ec, cfp, calling);
4594 }
4595 if (cme->def->type == VM_METHOD_TYPE_REFINED &&
4596 cme->def->body.refined.orig_me) {
4597 cme = refined_method_callable_without_refinement(cme);
4598 }
4599
4600 calling->cc = &VM_CC_ON_STACK(Qundef, vm_call_general, {{ 0 }}, cme);
4601
4602 return vm_call_method_each_type(ec, cfp, calling);
4603}
4604
4605static inline VALUE
4606find_refinement(VALUE refinements, VALUE klass)
4607{
4608 if (NIL_P(refinements)) {
4609 return Qnil;
4610 }
4611 return rb_hash_lookup(refinements, klass);
4612}
4613
4614PUREFUNC(static rb_control_frame_t * current_method_entry(const rb_execution_context_t *ec, rb_control_frame_t *cfp));
4615static rb_control_frame_t *
4616current_method_entry(const rb_execution_context_t *ec, rb_control_frame_t *cfp)
4617{
4618 rb_control_frame_t *top_cfp = cfp;
4619
4620 if (cfp->iseq && ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_BLOCK) {
4621 const rb_iseq_t *local_iseq = ISEQ_BODY(cfp->iseq)->local_iseq;
4622
4623 do {
4624 cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
4625 if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(ec, cfp)) {
4626 /* TODO: orphan block */
4627 return top_cfp;
4628 }
4629 } while (cfp->iseq != local_iseq);
4630 }
4631 return cfp;
4632}
4633
4634static const rb_callable_method_entry_t *
4635refined_method_callable_without_refinement(const rb_callable_method_entry_t *me)
4636{
4637 const rb_method_entry_t *orig_me = me->def->body.refined.orig_me;
4638 const rb_callable_method_entry_t *cme;
4639
4640 if (orig_me->defined_class == 0) {
4641 cme = NULL;
4643 }
4644 else {
4645 cme = (const rb_callable_method_entry_t *)orig_me;
4646 }
4647
4648 VM_ASSERT(callable_method_entry_p(cme));
4649
4650 if (UNDEFINED_METHOD_ENTRY_P(cme)) {
4651 cme = NULL;
4652 }
4653
4654 return cme;
4655}
4656
4657static const rb_callable_method_entry_t *
4658search_refined_method(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4659{
4660 const struct rb_callinfo *ci = calling->cd->ci;
4661 ID mid = vm_ci_mid(ci);
4662 // The initialize call of opt_new must behave like Class#new, which does not see the caller's refinements. [Bug #22501]
4663 const rb_cref_t *cref = (vm_ci_flag(ci) & VM_CALL_IGNORE_REFINEMENTS) ? NULL : vm_get_cref(cfp->ep);
4664 const struct rb_callcache * const cc = calling->cc;
4665 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4666
4667 for (; cref; cref = CREF_NEXT(cref)) {
4668 const VALUE refinement = find_refinement(CREF_REFINEMENTS(cref), vm_cc_cme(cc)->owner);
4669 if (NIL_P(refinement)) continue;
4670
4671 const rb_callable_method_entry_t *const ref_me =
4672 rb_callable_method_entry(refinement, mid);
4673
4674 if (ref_me) {
4675 if (vm_cc_call(cc) == vm_call_super_method) {
4676 const rb_control_frame_t *top_cfp = current_method_entry(ec, cfp);
4677 const rb_callable_method_entry_t *top_me = rb_vm_frame_method_entry(top_cfp);
4678 if (top_me && rb_method_definition_eq(ref_me->def, top_me->def)) {
4679 continue;
4680 }
4681 }
4682
4683 if (cme->def->type != VM_METHOD_TYPE_REFINED ||
4684 cme->def != ref_me->def) {
4685 cme = ref_me;
4686 }
4687 if (ref_me->def->type != VM_METHOD_TYPE_REFINED) {
4688 return cme;
4689 }
4690 }
4691 else {
4692 return NULL;
4693 }
4694 }
4695
4696 if (vm_cc_cme(cc)->def->body.refined.orig_me) {
4697 return refined_method_callable_without_refinement(vm_cc_cme(cc));
4698 }
4699 else {
4700 VALUE klass = RCLASS_SUPER(vm_cc_cme(cc)->defined_class);
4701 const rb_callable_method_entry_t *cme = klass ? rb_callable_method_entry(klass, mid) : NULL;
4702 return cme;
4703 }
4704}
4705
4706static VALUE
4707vm_call_refined(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4708{
4709 const rb_callable_method_entry_t *ref_cme = search_refined_method(ec, cfp, calling);
4710
4711 if (ref_cme) {
4712 if (calling->cd->cc) {
4713 const struct rb_callcache *cc = calling->cc = vm_cc_new(vm_cc_cme(calling->cc)->defined_class, ref_cme, vm_call_general, cc_type_refinement);
4714 RB_OBJ_WRITE(cfp->iseq, &calling->cd->cc, cc);
4715 return vm_call_method(ec, cfp, calling);
4716 }
4717 else {
4718 struct rb_callcache *ref_cc = &VM_CC_ON_STACK(Qundef, vm_call_general, {{ 0 }}, ref_cme);
4719 calling->cc= ref_cc;
4720 return vm_call_method(ec, cfp, calling);
4721 }
4722 }
4723 else {
4724 return vm_call_method_nome(ec, cfp, calling);
4725 }
4726}
4727
4728static inline VALUE vm_invoke_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling, const struct rb_callinfo *ci, bool is_lambda, VALUE block_handler);
4729
4730NOINLINE(static VALUE
4731 vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4732 struct rb_calling_info *calling, const struct rb_callinfo *ci, VALUE block_handler));
4733
4734static VALUE
4735vm_invoke_block_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
4736 struct rb_calling_info *calling, const struct rb_callinfo *ci, VALUE block_handler)
4737{
4738 int argc = calling->argc;
4739
4740 /* remove self */
4741 if (argc > 0) MEMMOVE(&TOPN(argc), &TOPN(argc-1), VALUE, argc);
4742 DEC_SP(1);
4743
4744 return vm_invoke_block(ec, reg_cfp, calling, ci, false, block_handler);
4745}
4746
4747static VALUE
4748vm_call_opt_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4749{
4750 RB_DEBUG_COUNTER_INC(ccf_opt_call);
4751
4752 const struct rb_callinfo *ci = calling->cd->ci;
4753 VALUE procval = calling->recv;
4754 return vm_invoke_block_opt_call(ec, reg_cfp, calling, ci, VM_BH_FROM_PROC(procval));
4755}
4756
4757static VALUE
4758vm_call_opt_block_call(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4759{
4760 RB_DEBUG_COUNTER_INC(ccf_opt_block_call);
4761
4762 VALUE block_handler = VM_ENV_BLOCK_HANDLER(VM_CF_LEP(reg_cfp));
4763 const struct rb_callinfo *ci = calling->cd->ci;
4764
4765 if (BASIC_OP_UNREDEFINED_P(BOP_CALL, PROC_REDEFINED_OP_FLAG)) {
4766 return vm_invoke_block_opt_call(ec, reg_cfp, calling, ci, block_handler);
4767 }
4768 else {
4769 calling->recv = rb_vm_bh_to_procval(ec, block_handler);
4770 calling->cc = rb_vm_search_method_slowpath(ci, CLASS_OF(calling->recv));
4771 return vm_call_general(ec, reg_cfp, calling);
4772 }
4773}
4774
4775static VALUE
4776vm_call_opt_struct_aref0(rb_execution_context_t *ec, struct rb_calling_info *calling)
4777{
4778 VALUE recv = calling->recv;
4779
4780 VM_ASSERT(RB_TYPE_P(recv, T_STRUCT));
4781 VM_ASSERT(vm_cc_cme(calling->cc)->def->type == VM_METHOD_TYPE_OPTIMIZED);
4782 VM_ASSERT(vm_cc_cme(calling->cc)->def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_AREF);
4783
4784 const unsigned int off = vm_cc_cme(calling->cc)->def->body.optimized.index;
4785 return internal_RSTRUCT_GET(recv, off);
4786}
4787
4788static VALUE
4789vm_call_opt_struct_aref(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4790{
4791 RB_DEBUG_COUNTER_INC(ccf_opt_struct_aref);
4792
4793 VALUE ret = vm_call_opt_struct_aref0(ec, calling);
4794 reg_cfp->sp -= 1;
4795 return ret;
4796}
4797
4798static VALUE
4799vm_call_opt_struct_aset0(rb_execution_context_t *ec, struct rb_calling_info *calling, VALUE val)
4800{
4801 VALUE recv = calling->recv;
4802
4803 VM_ASSERT(RB_TYPE_P(recv, T_STRUCT));
4804 VM_ASSERT(vm_cc_cme(calling->cc)->def->type == VM_METHOD_TYPE_OPTIMIZED);
4805 VM_ASSERT(vm_cc_cme(calling->cc)->def->body.optimized.type == OPTIMIZED_METHOD_TYPE_STRUCT_ASET);
4806
4807 rb_check_frozen(recv);
4808
4809 const unsigned int off = vm_cc_cme(calling->cc)->def->body.optimized.index;
4810 internal_RSTRUCT_SET(recv, off, val);
4811
4812 return val;
4813}
4814
4815static VALUE
4816vm_call_opt_struct_aset(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
4817{
4818 RB_DEBUG_COUNTER_INC(ccf_opt_struct_aset);
4819
4820 VALUE ret = vm_call_opt_struct_aset0(ec, calling, *(reg_cfp->sp - 1));
4821 reg_cfp->sp -= 2;
4822 return ret;
4823}
4824
4825NOINLINE(static VALUE vm_call_optimized(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling,
4826 const struct rb_callinfo *ci, const struct rb_callcache *cc));
4827
4828#define VM_CALL_METHOD_ATTR(var, func, nohook) \
4829 if (UNLIKELY(ruby_vm_c_events_enabled > 0)) { \
4830 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_CALL, calling->recv, vm_cc_cme(cc)->def->original_id, \
4831 vm_ci_mid(ci), vm_cc_cme(cc)->owner, Qundef); \
4832 var = func; \
4833 EXEC_EVENT_HOOK(ec, RUBY_EVENT_C_RETURN, calling->recv, vm_cc_cme(cc)->def->original_id, \
4834 vm_ci_mid(ci), vm_cc_cme(cc)->owner, (var)); \
4835 } \
4836 else { \
4837 nohook; \
4838 var = func; \
4839 }
4840
4841static VALUE
4842vm_call_optimized(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling,
4843 const struct rb_callinfo *ci, const struct rb_callcache *cc)
4844{
4845 switch (vm_cc_cme(cc)->def->body.optimized.type) {
4846 case OPTIMIZED_METHOD_TYPE_SEND:
4847 CC_SET_FASTPATH(cc, vm_call_opt_send, TRUE);
4848 return vm_call_opt_send(ec, cfp, calling);
4849 case OPTIMIZED_METHOD_TYPE_CALL:
4850 CC_SET_FASTPATH(cc, vm_call_opt_call, TRUE);
4851 return vm_call_opt_call(ec, cfp, calling);
4852 case OPTIMIZED_METHOD_TYPE_BLOCK_CALL:
4853 CC_SET_FASTPATH(cc, vm_call_opt_block_call, TRUE);
4854 return vm_call_opt_block_call(ec, cfp, calling);
4855 case OPTIMIZED_METHOD_TYPE_STRUCT_AREF: {
4856 CALLER_SETUP_ARG(cfp, calling, ci, 0);
4857 rb_check_arity(calling->argc, 0, 0);
4858
4859 VALUE v;
4860 VM_CALL_METHOD_ATTR(v,
4861 vm_call_opt_struct_aref(ec, cfp, calling),
4862 set_vm_cc_ivar(cc); \
4863 CC_SET_FASTPATH(cc, vm_call_opt_struct_aref, (vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE)))
4864 return v;
4865 }
4866 case OPTIMIZED_METHOD_TYPE_STRUCT_ASET: {
4867 CALLER_SETUP_ARG(cfp, calling, ci, 1);
4868 rb_check_arity(calling->argc, 1, 1);
4869
4870 VALUE v;
4871 VM_CALL_METHOD_ATTR(v,
4872 vm_call_opt_struct_aset(ec, cfp, calling),
4873 set_vm_cc_ivar(cc); \
4874 CC_SET_FASTPATH(cc, vm_call_opt_struct_aset, (vm_ci_flag(ci) & VM_CALL_ARGS_SIMPLE)))
4875 return v;
4876 }
4877 default:
4878 rb_bug("vm_call_method: unsupported optimized method type (%d)", vm_cc_cme(cc)->def->body.optimized.type);
4879 }
4880}
4881
4882static VALUE
4883vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4884{
4885 const struct rb_callinfo *ci = calling->cd->ci;
4886 const struct rb_callcache *cc = calling->cc;
4887 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4888 VALUE v;
4889
4890 VM_ASSERT(! METHOD_ENTRY_INVALIDATED(cme));
4891
4892 switch (cme->def->type) {
4893 case VM_METHOD_TYPE_ISEQ:
4894 if (ISEQ_BODY(def_iseq_ptr(cme->def))->param.flags.forwardable) {
4895 CC_SET_FASTPATH(cc, vm_call_iseq_fwd_setup, TRUE);
4896 return vm_call_iseq_fwd_setup(ec, cfp, calling);
4897 }
4898 else {
4899 CC_SET_FASTPATH(cc, vm_call_iseq_setup, TRUE);
4900 return vm_call_iseq_setup(ec, cfp, calling);
4901 }
4902
4903 case VM_METHOD_TYPE_NOTIMPLEMENTED:
4904 case VM_METHOD_TYPE_CFUNC:
4905 CC_SET_FASTPATH(cc, vm_call_cfunc, TRUE);
4906 return vm_call_cfunc(ec, cfp, calling);
4907
4908 case VM_METHOD_TYPE_ATTRSET:
4909 CALLER_SETUP_ARG(cfp, calling, ci, 1);
4910
4911 rb_check_arity(calling->argc, 1, 1);
4912
4913 const unsigned int aset_mask = (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT | VM_CALL_KWARG | VM_CALL_FORWARDING);
4914
4915 if (vm_cc_markable(cc)) {
4916 vm_cc_attr_index_initialize(cc, INVALID_SHAPE_ID);
4917 VM_CALL_METHOD_ATTR(v,
4918 vm_call_attrset_direct(ec, cfp, cc, calling->recv),
4919 CC_SET_FASTPATH(cc, vm_call_attrset, !(vm_ci_flag(ci) & aset_mask)));
4920 }
4921 else {
4922 cc = &((struct rb_callcache) {
4923 .flags = T_IMEMO |
4924 (imemo_callcache << FL_USHIFT) |
4925 VM_CALLCACHE_UNMARKABLE |
4926 VM_CALLCACHE_ON_STACK,
4927 .klass = cc->klass,
4928 .cme_ = cc->cme_,
4929 .call_ = cc->call_,
4930 .aux_ = {
4931 .attr = {
4932 .value = vm_pack_shape_and_index(INVALID_SHAPE_ID, ATTR_INDEX_NOT_SET),
4933 }
4934 },
4935 });
4936
4937 VM_CALL_METHOD_ATTR(v,
4938 vm_call_attrset_direct(ec, cfp, cc, calling->recv),
4939 CC_SET_FASTPATH(cc, vm_call_attrset, !(vm_ci_flag(ci) & aset_mask)));
4940 }
4941 return v;
4942
4943 case VM_METHOD_TYPE_IVAR:
4944 CALLER_SETUP_ARG(cfp, calling, ci, 0);
4945 rb_check_arity(calling->argc, 0, 0);
4946 vm_cc_attr_index_initialize(cc, INVALID_SHAPE_ID);
4947 const unsigned int ivar_mask = (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT | VM_CALL_FORWARDING);
4948 VM_CALL_METHOD_ATTR(v,
4949 vm_call_ivar(ec, cfp, calling),
4950 CC_SET_FASTPATH(cc, vm_call_ivar, !(vm_ci_flag(ci) & ivar_mask)));
4951 return v;
4952
4953 case VM_METHOD_TYPE_MISSING:
4954 vm_cc_method_missing_reason_set(cc, 0);
4955 CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);
4956 return vm_call_method_missing(ec, cfp, calling);
4957
4958 case VM_METHOD_TYPE_BMETHOD:
4959 CC_SET_FASTPATH(cc, vm_call_bmethod, TRUE);
4960 return vm_call_bmethod(ec, cfp, calling);
4961
4962 case VM_METHOD_TYPE_ALIAS:
4963 CC_SET_FASTPATH(cc, vm_call_alias, TRUE);
4964 return vm_call_alias(ec, cfp, calling);
4965
4966 case VM_METHOD_TYPE_OPTIMIZED:
4967 return vm_call_optimized(ec, cfp, calling, ci, cc);
4968
4969 case VM_METHOD_TYPE_UNDEF:
4970 break;
4971
4972 case VM_METHOD_TYPE_ZSUPER:
4973 return vm_call_zsuper(ec, cfp, calling, RCLASS_ORIGIN(vm_cc_cme(cc)->defined_class));
4974
4975 case VM_METHOD_TYPE_REFINED:
4976 // CC_SET_FASTPATH(cc, vm_call_refined, TRUE);
4977 // should not set FASTPATH since vm_call_refined assumes cc->call is vm_call_super_method on invokesuper.
4978 return vm_call_refined(ec, cfp, calling);
4979 }
4980
4981 rb_bug("vm_call_method: unsupported method type (%d)", vm_cc_cme(cc)->def->type);
4982}
4983
4984NORETURN(static void vm_raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv, VALUE obj, int call_status));
4985
4986static VALUE
4987vm_call_method_nome(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
4988{
4989 /* method missing */
4990 const struct rb_callinfo *ci = calling->cd->ci;
4991 const int stat = ci_missing_reason(ci);
4992
4993 if (vm_ci_mid(ci) == idMethodMissing) {
4994 if (UNLIKELY(calling->heap_argv)) {
4995 vm_raise_method_missing(ec, RARRAY_LENINT(calling->heap_argv), RARRAY_CONST_PTR(calling->heap_argv), calling->recv, stat);
4996 }
4997 else {
4998 rb_control_frame_t *reg_cfp = cfp;
4999 VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);
5000 vm_raise_method_missing(ec, calling->argc, argv, calling->recv, stat);
5001 }
5002 }
5003 else {
5004 return vm_call_method_missing_body(ec, cfp, calling, ci, stat);
5005 }
5006}
5007
5008/* Protected method calls and super invocations need to check that the receiver
5009 * (self for super) inherits the module on which the method is defined.
5010 * In the case of refinements, it should consider the original class not the
5011 * refinement.
5012 */
5013static VALUE
5014vm_defined_class_for_protected_call(const rb_callable_method_entry_t *me)
5015{
5016 VALUE defined_class = me->defined_class;
5017 VALUE refined_class = RCLASS_REFINED_CLASS(defined_class);
5018 return NIL_P(refined_class) ? defined_class : refined_class;
5019}
5020
5021static inline VALUE
5022vm_call_method(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling)
5023{
5024 const struct rb_callinfo *ci = calling->cd->ci;
5025 const struct rb_callcache *cc = calling->cc;
5026
5027 VM_ASSERT(callable_method_entry_p(vm_cc_cme(cc)));
5028
5029 if (vm_cc_cme(cc) != NULL) {
5030 switch (METHOD_ENTRY_VISI(vm_cc_cme(cc))) {
5031 case METHOD_VISI_PUBLIC: /* likely */
5032 return vm_call_method_each_type(ec, cfp, calling);
5033
5034 case METHOD_VISI_PRIVATE:
5035 if (!(vm_ci_flag(ci) & VM_CALL_FCALL)) {
5036 enum method_missing_reason stat = MISSING_PRIVATE;
5037 if (vm_ci_flag(ci) & VM_CALL_VCALL) stat |= MISSING_VCALL;
5038
5039 vm_cc_method_missing_reason_set(cc, stat);
5040 CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);
5041 return vm_call_method_missing(ec, cfp, calling);
5042 }
5043 return vm_call_method_each_type(ec, cfp, calling);
5044
5045 case METHOD_VISI_PROTECTED:
5046 if (!(vm_ci_flag(ci) & (VM_CALL_OPT_SEND | VM_CALL_FCALL))) {
5047 VALUE defined_class = vm_defined_class_for_protected_call(vm_cc_cme(cc));
5048 if (!rb_obj_is_kind_of(cfp->self, defined_class)) {
5049 vm_cc_method_missing_reason_set(cc, MISSING_PROTECTED);
5050 return vm_call_method_missing(ec, cfp, calling);
5051 }
5052 else {
5053 /* caching method info to dummy cc */
5054 VM_ASSERT(vm_cc_cme(cc) != NULL);
5055 struct rb_callcache cc_on_stack = *cc;
5056 FL_SET_RAW((VALUE)&cc_on_stack, VM_CALLCACHE_UNMARKABLE);
5057 calling->cc = &cc_on_stack;
5058 return vm_call_method_each_type(ec, cfp, calling);
5059 }
5060 }
5061 return vm_call_method_each_type(ec, cfp, calling);
5062
5063 default:
5064 rb_bug("unreachable");
5065 }
5066 }
5067 else {
5068 return vm_call_method_nome(ec, cfp, calling);
5069 }
5070}
5071
5072static VALUE
5073vm_call_general(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
5074{
5075 RB_DEBUG_COUNTER_INC(ccf_general);
5076 return vm_call_method(ec, reg_cfp, calling);
5077}
5078
5079void
5080rb_vm_cc_general(const struct rb_callcache *cc)
5081{
5082 VM_ASSERT(IMEMO_TYPE_P(cc, imemo_callcache));
5083 VM_ASSERT(cc != vm_cc_empty());
5084
5085 *(vm_call_handler *)&cc->call_ = vm_call_general;
5086}
5087
5088static VALUE
5089vm_call_super_method(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling)
5090{
5091 RB_DEBUG_COUNTER_INC(ccf_super_method);
5092
5093 // This line is introduced to make different from `vm_call_general` because some compilers (VC we found)
5094 // can merge the function and the address of the function becomes same.
5095 // The address of `vm_call_super_method` is used in `search_refined_method`, so it should be different.
5096 if (ec == NULL) rb_bug("unreachable");
5097
5098 /* this check is required to distinguish with other functions. */
5099 VM_ASSERT(vm_cc_call(calling->cc) == vm_call_super_method);
5100 return vm_call_method(ec, reg_cfp, calling);
5101}
5102
5103/* super */
5104
5105static inline VALUE
5106vm_search_normal_superclass(VALUE klass)
5107{
5108 if (BUILTIN_TYPE(klass) == T_ICLASS &&
5109 RB_TYPE_P(RBASIC(klass)->klass, T_MODULE) &&
5110 FL_TEST_RAW(RBASIC(klass)->klass, RMODULE_IS_REFINEMENT)) {
5111 klass = RBASIC(klass)->klass;
5112 }
5113 klass = RCLASS_ORIGIN(klass);
5114 return RCLASS_SUPER(klass);
5115}
5116
5117NORETURN(static void vm_super_outside(void));
5118
5119static void
5120vm_super_outside(void)
5121{
5122 rb_raise(rb_eNoMethodError, "super called outside of method");
5123}
5124
5125static const struct rb_callcache *
5126empty_cc_for_super(void)
5127{
5128 return &vm_empty_cc_for_super;
5129}
5130
5131static const struct rb_callcache *
5132vm_search_super_method(const rb_control_frame_t *reg_cfp, struct rb_call_data *cd, VALUE recv)
5133{
5134 VALUE current_defined_class;
5135 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(reg_cfp);
5136
5137 if (!me) {
5138 vm_super_outside();
5139 }
5140
5141 current_defined_class = vm_defined_class_for_protected_call(me);
5142
5143 if (BUILTIN_TYPE(current_defined_class) != T_MODULE &&
5144 reg_cfp->iseq != method_entry_iseqptr(me) &&
5145 !rb_obj_is_kind_of(recv, current_defined_class)) {
5146 VALUE m = RB_TYPE_P(current_defined_class, T_ICLASS) ?
5147 RCLASS_INCLUDER(current_defined_class) : current_defined_class;
5148
5149 if (m) { /* not bound UnboundMethod */
5150 rb_raise(rb_eTypeError,
5151 "self has wrong type to call super in this context: "
5152 "%"PRIsVALUE" (expected %"PRIsVALUE")",
5153 rb_obj_class(recv), m);
5154 }
5155 }
5156
5157 if (me->def->type == VM_METHOD_TYPE_BMETHOD && (vm_ci_flag(cd->ci) & VM_CALL_ZSUPER)) {
5158 rb_raise(rb_eRuntimeError,
5159 "implicit argument passing of super from method defined"
5160 " by define_method() is not supported."
5161 " Specify all arguments explicitly.");
5162 }
5163
5164 ID mid = me->def->original_id;
5165
5166 if (!vm_ci_markable(cd->ci)) {
5167 VM_FORCE_WRITE((const VALUE *)&cd->ci->mid, (VALUE)mid);
5168 }
5169 else {
5170 // update iseq. really? (TODO)
5171 cd->ci = vm_ci_new_runtime(mid,
5172 vm_ci_flag(cd->ci),
5173 vm_ci_argc(cd->ci),
5174 vm_ci_kwarg(cd->ci));
5175
5176 RB_OBJ_WRITTEN(reg_cfp->iseq, Qundef, cd->ci);
5177 }
5178
5179 const struct rb_callcache *cc;
5180
5181 VALUE klass = vm_search_normal_superclass(me->defined_class);
5182
5183 if (!klass) {
5184 /* bound instance method of module */
5185 cc = vm_cc_new(Qundef, NULL, vm_call_method_missing, cc_type_super);
5186 RB_OBJ_WRITE(reg_cfp->iseq, &cd->cc, cc);
5187 }
5188 else {
5189 cc = vm_search_method_fastpath((VALUE)reg_cfp->iseq, cd, klass);
5190 const rb_callable_method_entry_t *cached_cme = vm_cc_cme(cc);
5191
5192 // define_method can cache for different method id
5193 if (cached_cme == NULL) {
5194 // empty_cc_for_super is not markable object
5195 cd->cc = empty_cc_for_super();
5196 }
5197 else if (cached_cme->called_id != mid) {
5198 const rb_callable_method_entry_t *cme = rb_callable_method_entry(klass, mid);
5199 if (cme) {
5200 cc = vm_cc_new(klass, cme, vm_call_super_method, cc_type_super);
5201 RB_OBJ_WRITE(reg_cfp->iseq, &cd->cc, cc);
5202 }
5203 else {
5204 cd->cc = cc = empty_cc_for_super();
5205 }
5206 }
5207 else {
5208 switch (cached_cme->def->type) {
5209 // vm_call_refined (search_refined_method) assumes cc->call is vm_call_super_method on invokesuper
5210 case VM_METHOD_TYPE_REFINED:
5211 // cc->klass is superclass of receiver class. Checking cc->klass is not enough to invalidate IVC for the receiver class.
5212 case VM_METHOD_TYPE_ATTRSET:
5213 case VM_METHOD_TYPE_IVAR:
5214 vm_cc_call_set(cc, vm_call_super_method); // invalidate fastpath
5215 break;
5216 default:
5217 break; // use fastpath
5218 }
5219 }
5220 }
5221
5222 VM_ASSERT((vm_cc_cme(cc), true));
5223
5224 return cc;
5225}
5226
5227/* yield */
5228
5229static inline int
5230block_proc_is_lambda(const VALUE procval)
5231{
5232 rb_proc_t *proc;
5233
5234 if (procval) {
5235 GetProcPtr(procval, proc);
5236 return proc->is_lambda;
5237 }
5238 else {
5239 return 0;
5240 }
5241}
5242
5243static VALUE
5244vm_yield_with_cfunc(rb_execution_context_t *ec,
5245 const struct rb_captured_block *captured,
5246 VALUE self, int argc, const VALUE *argv, int kw_splat, VALUE block_handler,
5247 const rb_callable_method_entry_t *me)
5248{
5249 int is_lambda = FALSE; /* TODO */
5250 VALUE val, arg, blockarg;
5251 int frame_flag;
5252 const struct vm_ifunc *ifunc = captured->code.ifunc;
5253
5254 if (is_lambda) {
5255 arg = rb_ary_new4(argc, argv);
5256 }
5257 else if (argc == 0) {
5258 arg = Qnil;
5259 }
5260 else {
5261 arg = argv[0];
5262 }
5263
5264 blockarg = rb_vm_bh_to_procval(ec, block_handler);
5265
5266 frame_flag = VM_FRAME_MAGIC_IFUNC | VM_FRAME_FLAG_CFRAME | (me ? VM_FRAME_FLAG_BMETHOD : 0);
5267 if (kw_splat) {
5268 frame_flag |= VM_FRAME_FLAG_CFRAME_KW;
5269 }
5270
5271 vm_push_frame(ec, (const rb_iseq_t *)captured->code.ifunc,
5272 frame_flag,
5273 self,
5274 VM_GUARDED_PREV_EP(captured->ep),
5275 (VALUE)me,
5276 0, ec->cfp->sp, 0, 0);
5277 val = (*ifunc->func)(arg, (VALUE)ifunc->data, argc, argv, blockarg);
5278 rb_vm_pop_frame(ec);
5279
5280 return val;
5281}
5282
5283VALUE
5284rb_vm_yield_with_cfunc(rb_execution_context_t *ec, const struct rb_captured_block *captured, int argc, const VALUE *argv)
5285{
5286 return vm_yield_with_cfunc(ec, captured, captured->self, argc, argv, 0, VM_BLOCK_HANDLER_NONE, NULL);
5287}
5288
5289static VALUE
5290vm_yield_with_symbol(rb_execution_context_t *ec, VALUE symbol, int argc, const VALUE *argv, int kw_splat, VALUE block_handler)
5291{
5292 return rb_sym_proc_call(SYM2ID(symbol), argc, argv, kw_splat, rb_vm_bh_to_procval(ec, block_handler));
5293}
5294
5295static inline int
5296vm_callee_setup_block_arg_arg0_splat(rb_control_frame_t *cfp, const rb_iseq_t *iseq, VALUE *argv, VALUE ary)
5297{
5298 int i;
5299 long len = RARRAY_LEN(ary);
5300
5301 CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
5302
5303 for (i=0; i<len && i<ISEQ_BODY(iseq)->param.lead_num; i++) {
5304 argv[i] = RARRAY_AREF(ary, i);
5305 }
5306
5307 return i;
5308}
5309
5310static inline VALUE
5311vm_callee_setup_block_arg_arg0_check(VALUE *argv)
5312{
5313 VALUE ary, arg0 = argv[0];
5314 ary = rb_check_array_type(arg0);
5315#if 0
5316 argv[0] = arg0;
5317#else
5318 VM_ASSERT(argv[0] == arg0);
5319#endif
5320 return ary;
5321}
5322
5323static int
5324vm_callee_setup_block_arg(rb_execution_context_t *ec, struct rb_calling_info *calling, const struct rb_callinfo *ci, const rb_iseq_t *iseq, VALUE *argv, const enum arg_setup_type arg_setup_type)
5325{
5326 if (rb_simple_iseq_p(iseq)) {
5327 rb_control_frame_t *cfp = ec->cfp;
5328 VALUE arg0;
5329
5330 CALLER_SETUP_ARG(cfp, calling, ci, ISEQ_BODY(iseq)->param.lead_num);
5331
5332 if (arg_setup_type == arg_setup_block &&
5333 calling->argc == 1 &&
5334 ISEQ_BODY(iseq)->param.flags.has_lead &&
5335 !ISEQ_BODY(iseq)->param.flags.ambiguous_param0 &&
5336 !NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv))) {
5337 calling->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0);
5338 }
5339
5340 if (calling->argc != ISEQ_BODY(iseq)->param.lead_num) {
5341 if (arg_setup_type == arg_setup_block) {
5342 if (calling->argc < ISEQ_BODY(iseq)->param.lead_num) {
5343 int i;
5344 CHECK_VM_STACK_OVERFLOW(cfp, ISEQ_BODY(iseq)->param.lead_num);
5345 for (i=calling->argc; i<ISEQ_BODY(iseq)->param.lead_num; i++) argv[i] = Qnil;
5346 calling->argc = ISEQ_BODY(iseq)->param.lead_num; /* fill rest parameters */
5347 }
5348 else if (calling->argc > ISEQ_BODY(iseq)->param.lead_num) {
5349 calling->argc = ISEQ_BODY(iseq)->param.lead_num; /* simply truncate arguments */
5350 }
5351 }
5352 else {
5353 argument_arity_error(ec, iseq, NULL, calling->argc, ISEQ_BODY(iseq)->param.lead_num, ISEQ_BODY(iseq)->param.lead_num);
5354 }
5355 }
5356
5357 return 0;
5358 }
5359 else {
5360 return setup_parameters_complex(ec, iseq, calling, ci, argv, arg_setup_type);
5361 }
5362}
5363
5364static int
5365vm_yield_setup_args(rb_execution_context_t *ec, const rb_iseq_t *iseq, const int argc, VALUE *argv, int flags, VALUE block_handler, enum arg_setup_type arg_setup_type)
5366{
5367 struct rb_calling_info calling_entry, *calling;
5368
5369 calling = &calling_entry;
5370 calling->argc = argc;
5371 calling->block_handler = block_handler;
5372 calling->kw_splat = (flags & VM_CALL_KW_SPLAT) ? 1 : 0;
5373 calling->recv = Qundef;
5374 calling->heap_argv = 0;
5375 calling->cc = NULL;
5376 struct rb_callinfo dummy_ci = VM_CI_ON_STACK(0, flags, 0, 0);
5377
5378 return vm_callee_setup_block_arg(ec, calling, &dummy_ci, iseq, argv, arg_setup_type);
5379}
5380
5381/* ruby iseq -> ruby block */
5382
5383static VALUE
5384vm_invoke_iseq_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5385 struct rb_calling_info *calling, const struct rb_callinfo *ci,
5386 bool is_lambda, VALUE block_handler)
5387{
5388 const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(block_handler);
5389 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
5390 const int arg_size = ISEQ_BODY(iseq)->param.size;
5391 VALUE * const rsp = GET_SP() - calling->argc;
5392 VALUE * const argv = rsp;
5393 int opt_pc = vm_callee_setup_block_arg(ec, calling, ci, iseq, argv, is_lambda ? arg_setup_method : arg_setup_block);
5394 int frame_flag = VM_FRAME_MAGIC_BLOCK | (is_lambda ? VM_FRAME_FLAG_LAMBDA : 0);
5395
5396 SET_SP(rsp);
5397
5398 vm_push_frame(ec, iseq,
5399 frame_flag,
5400 captured->self,
5401 VM_GUARDED_PREV_EP(captured->ep), 0,
5402 ISEQ_BODY(iseq)->iseq_encoded + opt_pc,
5403 rsp + arg_size,
5404 ISEQ_BODY(iseq)->local_table_size - arg_size, ISEQ_BODY(iseq)->stack_max);
5405
5406 return Qundef;
5407}
5408
5409static VALUE
5410vm_invoke_symbol_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5411 struct rb_calling_info *calling, const struct rb_callinfo *ci,
5412 MAYBE_UNUSED(bool is_lambda), VALUE block_handler)
5413{
5414 VALUE symbol = VM_BH_TO_SYMBOL(block_handler);
5415 int flags = vm_ci_flag(ci);
5416
5417 if (UNLIKELY(!(flags & VM_CALL_ARGS_SIMPLE) &&
5418 ((calling->argc == 0) ||
5419 (calling->argc == 1 && (flags & (VM_CALL_ARGS_SPLAT | VM_CALL_KW_SPLAT))) ||
5420 (calling->argc == 2 && (flags & VM_CALL_ARGS_SPLAT) && (flags & VM_CALL_KW_SPLAT)) ||
5421 ((flags & VM_CALL_KWARG) && (vm_ci_kwarg(ci)->keyword_len == calling->argc))))) {
5422 CALLER_SETUP_ARG(reg_cfp, calling, ci, ALLOW_HEAP_ARGV);
5423 flags = 0;
5424 if (UNLIKELY(calling->heap_argv)) {
5425#if VM_ARGC_STACK_MAX < 0
5426 if (RARRAY_LEN(calling->heap_argv) < 1) {
5427 rb_raise(rb_eArgError, "no receiver given");
5428 }
5429#endif
5430 calling->recv = rb_ary_shift(calling->heap_argv);
5431 // Modify stack to avoid cfp consistency error
5432 reg_cfp->sp++;
5433 reg_cfp->sp[-1] = reg_cfp->sp[-2];
5434 reg_cfp->sp[-2] = calling->recv;
5435 flags |= VM_CALL_ARGS_SPLAT;
5436 }
5437 else {
5438 if (calling->argc < 1) {
5439 rb_raise(rb_eArgError, "no receiver given");
5440 }
5441 calling->recv = TOPN(--calling->argc);
5442 }
5443 if (calling->kw_splat) {
5444 flags |= VM_CALL_KW_SPLAT;
5445 }
5446 }
5447 else {
5448 if (calling->argc < 1) {
5449 rb_raise(rb_eArgError, "no receiver given");
5450 }
5451 calling->recv = TOPN(--calling->argc);
5452 }
5453
5454 return vm_call_symbol(ec, reg_cfp, calling, ci, symbol, flags);
5455}
5456
5457static VALUE
5458vm_invoke_ifunc_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5459 struct rb_calling_info *calling, const struct rb_callinfo *ci,
5460 MAYBE_UNUSED(bool is_lambda), VALUE block_handler)
5461{
5462 VALUE val;
5463 int argc;
5464 const struct rb_captured_block *captured = VM_BH_TO_IFUNC_BLOCK(block_handler);
5465 CALLER_SETUP_ARG(ec->cfp, calling, ci, ALLOW_HEAP_ARGV_KEEP_KWSPLAT);
5466 argc = calling->argc;
5467 val = vm_yield_with_cfunc(ec, captured, captured->self, CALLING_ARGC(calling), calling->heap_argv ? RARRAY_CONST_PTR(calling->heap_argv) : STACK_ADDR_FROM_TOP(argc), calling->kw_splat, calling->block_handler, NULL);
5468 POPN(argc); /* TODO: should put before C/yield? */
5469 return val;
5470}
5471
5472static VALUE
5473vm_proc_to_block_handler(VALUE procval)
5474{
5475 const struct rb_block *block = vm_proc_block(procval);
5476
5477 switch (vm_block_type(block)) {
5478 case block_type_iseq:
5479 return VM_BH_FROM_ISEQ_BLOCK(&block->as.captured);
5480 case block_type_ifunc:
5481 return VM_BH_FROM_IFUNC_BLOCK(&block->as.captured);
5482 case block_type_symbol:
5483 return VM_BH_FROM_SYMBOL(block->as.symbol);
5484 case block_type_proc:
5485 return VM_BH_FROM_PROC(block->as.proc);
5486 }
5487 VM_UNREACHABLE(vm_yield_with_proc);
5488 return Qundef;
5489}
5490
5491static VALUE
5492vm_invoke_proc_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5493 struct rb_calling_info *calling, const struct rb_callinfo *ci,
5494 bool is_lambda, VALUE block_handler)
5495{
5496 while (vm_block_handler_type(block_handler) == block_handler_type_proc) {
5497 VALUE proc = VM_BH_TO_PROC(block_handler);
5498 is_lambda = block_proc_is_lambda(proc);
5499 block_handler = vm_proc_to_block_handler(proc);
5500 }
5501
5502 return vm_invoke_block(ec, reg_cfp, calling, ci, is_lambda, block_handler);
5503}
5504
5505static inline VALUE
5506vm_invoke_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5507 struct rb_calling_info *calling, const struct rb_callinfo *ci,
5508 bool is_lambda, VALUE block_handler)
5509{
5510 VALUE (*func)(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp,
5511 struct rb_calling_info *calling, const struct rb_callinfo *ci,
5512 bool is_lambda, VALUE block_handler);
5513
5514 switch (vm_block_handler_type(block_handler)) {
5515 case block_handler_type_iseq: func = vm_invoke_iseq_block; break;
5516 case block_handler_type_ifunc: func = vm_invoke_ifunc_block; break;
5517 case block_handler_type_proc: func = vm_invoke_proc_block; break;
5518 case block_handler_type_symbol: func = vm_invoke_symbol_block; break;
5519 default: rb_bug("vm_invoke_block: unreachable");
5520 }
5521
5522 return func(ec, reg_cfp, calling, ci, is_lambda, block_handler);
5523}
5524
5525static VALUE
5526vm_make_proc_with_iseq(const rb_iseq_t *blockiseq)
5527{
5528 const rb_execution_context_t *ec = GET_EC();
5529 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
5530 struct rb_captured_block *captured;
5531
5532 if (cfp == 0) {
5533 rb_bug("vm_make_proc_with_iseq: unreachable");
5534 }
5535
5536 captured = VM_CFP_TO_CAPTURED_BLOCK(cfp);
5537 captured->code.iseq = blockiseq;
5538
5539 return rb_vm_make_proc(ec, captured, rb_cProc);
5540}
5541
5542static VALUE
5543vm_once_exec(VALUE iseq)
5544{
5545 VALUE proc = vm_make_proc_with_iseq((rb_iseq_t *)iseq);
5546 return rb_proc_call_with_block(proc, 0, 0, Qnil);
5547}
5548
5549static VALUE
5550vm_once_clear(VALUE data)
5551{
5552 union iseq_inline_storage_entry *is = (union iseq_inline_storage_entry *)data;
5553 is->once.running_thread = NULL;
5554 return Qnil;
5555}
5556
5557/* defined insn */
5558
5559static bool
5560check_respond_to_missing(VALUE obj, VALUE v)
5561{
5562 VALUE args[2];
5563 VALUE r;
5564
5565 args[0] = obj; args[1] = Qfalse;
5566 r = rb_check_funcall(v, idRespond_to_missing, 2, args);
5567 if (!UNDEF_P(r) && RTEST(r)) {
5568 return true;
5569 }
5570 else {
5571 return false;
5572 }
5573}
5574
5575static bool
5576vm_defined(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t op_type, VALUE obj, VALUE v)
5577{
5578 VALUE klass;
5579 enum defined_type type = (enum defined_type)op_type;
5580
5581 switch (type) {
5582 case DEFINED_IVAR:
5583 return rb_ivar_defined(GET_SELF(), SYM2ID(obj));
5584 break;
5585 case DEFINED_GVAR:
5586 return rb_gvar_defined(SYM2ID(obj));
5587 break;
5588 case DEFINED_CVAR: {
5589 const rb_cref_t *cref = vm_get_cref(GET_EP());
5590 klass = vm_get_cvar_base(cref, GET_CFP(), 0);
5591 return rb_cvar_defined(klass, SYM2ID(obj));
5592 break;
5593 }
5594 case DEFINED_CONST:
5595 case DEFINED_CONST_FROM: {
5596 bool allow_nil = type == DEFINED_CONST;
5597 klass = v;
5598 return vm_get_ev_const(ec, klass, SYM2ID(obj), allow_nil, true);
5599 break;
5600 }
5601 case DEFINED_FUNC:
5602 klass = CLASS_OF(v);
5603 return rb_ec_obj_respond_to(ec, v, SYM2ID(obj), TRUE);
5604 break;
5605 case DEFINED_METHOD:{
5606 VALUE klass = CLASS_OF(v);
5607 const rb_callable_method_entry_t *cme = rb_callable_method_entry_with_refinements(klass, SYM2ID(obj), NULL);
5608
5609 if (cme) {
5610 switch (METHOD_ENTRY_VISI(cme)) {
5611 case METHOD_VISI_PRIVATE:
5612 break;
5613 case METHOD_VISI_PROTECTED:
5614 if (!rb_obj_is_kind_of(GET_SELF(), vm_defined_class_for_protected_call(cme))) {
5615 break;
5616 }
5617 case METHOD_VISI_PUBLIC:
5618 return true;
5619 break;
5620 default:
5621 rb_bug("vm_defined: unreachable: %u", (unsigned int)METHOD_ENTRY_VISI(cme));
5622 }
5623 }
5624 else {
5625 return check_respond_to_missing(obj, v);
5626 }
5627 break;
5628 }
5629 case DEFINED_YIELD:
5630 if (GET_BLOCK_HANDLER() != VM_BLOCK_HANDLER_NONE) {
5631 return true;
5632 }
5633 break;
5634 case DEFINED_ZSUPER:
5635 {
5636 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(GET_CFP());
5637
5638 if (me) {
5639 VALUE klass = vm_search_normal_superclass(me->defined_class);
5640 if (!klass) return false;
5641
5642 ID id = me->def->original_id;
5643
5644 return rb_method_boundp(klass, id, 0);
5645 }
5646 }
5647 break;
5648 case DEFINED_REF:
5649 return RTEST(vm_backref_defined(ec, GET_LEP(), FIX2INT(obj)));
5650 default:
5651 rb_bug("unimplemented defined? type (VM)");
5652 break;
5653 }
5654
5655 return false;
5656}
5657
5658bool
5659rb_vm_defined(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, rb_num_t op_type, VALUE obj, VALUE v)
5660{
5661 return vm_defined(ec, reg_cfp, op_type, obj, v);
5662}
5663
5664static const VALUE *
5665vm_get_ep(const VALUE *const reg_ep, rb_num_t lv)
5666{
5667 rb_num_t i;
5668 const VALUE *ep = reg_ep;
5669 for (i = 0; i < lv; i++) {
5670 ep = GET_PREV_EP(ep);
5671 }
5672 return ep;
5673}
5674
5675static VALUE
5676vm_get_special_object(const VALUE *const reg_ep,
5677 enum vm_special_object_type type)
5678{
5679 switch (type) {
5680 case VM_SPECIAL_OBJECT_VMCORE:
5681 return rb_mRubyVMFrozenCore;
5682 case VM_SPECIAL_OBJECT_CBASE:
5683 return vm_get_cbase(reg_ep);
5684 case VM_SPECIAL_OBJECT_CONST_BASE:
5685 return vm_get_const_base(reg_ep);
5686 default:
5687 rb_bug("putspecialobject insn: unknown value_type %d", type);
5688 }
5689}
5690
5691// ZJIT implementation is using the C function
5692// and needs to call a non-static function
5693VALUE
5694rb_vm_get_special_object(const VALUE *reg_ep, enum vm_special_object_type type)
5695{
5696 return vm_get_special_object(reg_ep, type);
5697}
5698
5699static VALUE
5700vm_concat_array(VALUE ary1, VALUE ary2st)
5701{
5702 const VALUE ary2 = ary2st;
5703 VALUE tmp1 = rb_check_to_array(ary1);
5704 VALUE tmp2 = rb_check_to_array(ary2);
5705
5706 if (NIL_P(tmp1)) {
5707 tmp1 = rb_ary_new3(1, ary1);
5708 }
5709 if (tmp1 == ary1) {
5710 tmp1 = rb_ary_dup(ary1);
5711 }
5712
5713 if (NIL_P(tmp2)) {
5714 return rb_ary_push(tmp1, ary2);
5715 }
5716 else {
5717 return rb_ary_concat(tmp1, tmp2);
5718 }
5719}
5720
5721static VALUE
5722vm_concat_to_array(VALUE ary1, VALUE ary2st)
5723{
5724 /* ary1 must be a newly created array */
5725 const VALUE ary2 = ary2st;
5726
5727 if (NIL_P(ary2)) return ary1;
5728
5729 VALUE tmp2 = rb_check_to_array(ary2);
5730
5731 if (NIL_P(tmp2)) {
5732 return rb_ary_push(ary1, ary2);
5733 }
5734 else {
5735 return rb_ary_concat(ary1, tmp2);
5736 }
5737}
5738
5739// YJIT implementation is using the C function
5740// and needs to call a non-static function
5741VALUE
5742rb_vm_concat_array(VALUE ary1, VALUE ary2st)
5743{
5744 return vm_concat_array(ary1, ary2st);
5745}
5746
5747VALUE
5748rb_vm_concat_to_array(VALUE ary1, VALUE ary2st)
5749{
5750 return vm_concat_to_array(ary1, ary2st);
5751}
5752
5753static VALUE
5754vm_splat_array(VALUE flag, VALUE ary)
5755{
5756 if (NIL_P(ary)) {
5757 return RTEST(flag) ? rb_ary_new() : rb_cArray_empty_frozen;
5758 }
5759 VALUE tmp = rb_check_to_array(ary);
5760 if (NIL_P(tmp)) {
5761 return rb_ary_new3(1, ary);
5762 }
5763 else if (RTEST(flag)) {
5764 return rb_ary_dup(tmp);
5765 }
5766 else {
5767 return tmp;
5768 }
5769}
5770
5771// YJIT implementation is using the C function
5772// and needs to call a non-static function
5773VALUE
5774rb_vm_splat_array(VALUE flag, VALUE ary)
5775{
5776 return vm_splat_array(flag, ary);
5777}
5778
5779static VALUE
5780vm_check_match(rb_execution_context_t *ec, VALUE target, VALUE pattern, rb_num_t flag)
5781{
5782 enum vm_check_match_type type = ((int)flag) & VM_CHECKMATCH_TYPE_MASK;
5783
5784 if (flag & VM_CHECKMATCH_ARRAY) {
5785 long i;
5786 const long n = RARRAY_LEN(pattern);
5787
5788 for (i = 0; i < n; i++) {
5789 VALUE v = RARRAY_AREF(pattern, i);
5790 VALUE c = check_match(ec, v, target, type);
5791
5792 if (RTEST(c)) {
5793 return c;
5794 }
5795 }
5796 return Qfalse;
5797 }
5798 else {
5799 return check_match(ec, pattern, target, type);
5800 }
5801}
5802
5803VALUE
5804rb_vm_check_match(rb_execution_context_t *ec, VALUE target, VALUE pattern, rb_num_t flag)
5805{
5806 return vm_check_match(ec, target, pattern, flag);
5807}
5808
5809static VALUE
5810vm_check_keyword(lindex_t bits, lindex_t idx, const VALUE *ep)
5811{
5812 const VALUE kw_bits = *(ep - bits);
5813
5814 if (FIXNUM_P(kw_bits)) {
5815 unsigned int b = (unsigned int)FIX2ULONG(kw_bits);
5816 if ((idx < VM_KW_SPECIFIED_BITS_MAX) && (b & (0x01 << idx)))
5817 return Qfalse;
5818 }
5819 else {
5820 VM_ASSERT(RB_TYPE_P(kw_bits, T_HASH));
5821 if (rb_hash_has_key(kw_bits, INT2FIX(idx))) return Qfalse;
5822 }
5823 return Qtrue;
5824}
5825
5826static void
5827vm_dtrace(rb_event_flag_t flag, rb_execution_context_t *ec)
5828{
5829 if (RUBY_DTRACE_METHOD_ENTRY_ENABLED() ||
5830 RUBY_DTRACE_METHOD_RETURN_ENABLED() ||
5831 RUBY_DTRACE_CMETHOD_ENTRY_ENABLED() ||
5832 RUBY_DTRACE_CMETHOD_RETURN_ENABLED()) {
5833
5834 switch (flag) {
5835 case RUBY_EVENT_CALL:
5836 RUBY_DTRACE_METHOD_ENTRY_HOOK(ec, 0, 0);
5837 return;
5838 case RUBY_EVENT_C_CALL:
5839 RUBY_DTRACE_CMETHOD_ENTRY_HOOK(ec, 0, 0);
5840 return;
5841 case RUBY_EVENT_RETURN:
5842 RUBY_DTRACE_METHOD_RETURN_HOOK(ec, 0, 0);
5843 return;
5845 RUBY_DTRACE_CMETHOD_RETURN_HOOK(ec, 0, 0);
5846 return;
5847 }
5848 }
5849}
5850
5851static VALUE
5852vm_const_get_under(ID id, rb_num_t flags, VALUE cbase)
5853{
5854 if (!rb_const_defined_at(cbase, id)) {
5855 return 0;
5856 }
5857 else if (VM_DEFINECLASS_SCOPED_P(flags)) {
5858 return rb_public_const_get_at(cbase, id);
5859 }
5860 else {
5861 return rb_const_get_at(cbase, id);
5862 }
5863}
5864
5865static VALUE
5866vm_check_if_class(ID id, rb_num_t flags, VALUE super, VALUE klass)
5867{
5868 if (!RB_TYPE_P(klass, T_CLASS)) {
5869 return 0;
5870 }
5871 else if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags)) {
5872 VALUE tmp = rb_class_real(RCLASS_SUPER(klass));
5873
5874 if (tmp != super) {
5875 rb_raise(rb_eTypeError,
5876 "superclass mismatch for class %"PRIsVALUE"",
5877 rb_id2str(id));
5878 }
5879 else {
5880 return klass;
5881 }
5882 }
5883 else {
5884 return klass;
5885 }
5886}
5887
5888static VALUE
5889vm_check_if_module(ID id, VALUE mod)
5890{
5891 if (!RB_TYPE_P(mod, T_MODULE)) {
5892 return 0;
5893 }
5894 else {
5895 return mod;
5896 }
5897}
5898
5899static VALUE
5900declare_under(ID id, VALUE cbase, VALUE c)
5901{
5902 rb_set_class_path_string(c, cbase, rb_id2str(id));
5903 rb_const_set(cbase, id, c);
5904 return c;
5905}
5906
5907static VALUE
5908vm_declare_class(ID id, rb_num_t flags, VALUE cbase, VALUE super)
5909{
5910 /* new class declaration */
5911 VALUE s = VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) ? super : rb_cObject;
5912 VALUE c = declare_under(id, cbase, rb_define_class_id(id, s));
5914 rb_class_inherited(s, c);
5915 return c;
5916}
5917
5918static VALUE
5919vm_declare_module(ID id, VALUE cbase)
5920{
5921 /* new module declaration */
5922 return declare_under(id, cbase, rb_module_new());
5923}
5924
5925NORETURN(static void unmatched_redefinition(const char *type, VALUE cbase, ID id, VALUE old));
5926static void
5927unmatched_redefinition(const char *type, VALUE cbase, ID id, VALUE old)
5928{
5929 VALUE name = rb_id2str(id);
5930 VALUE message = rb_sprintf("%"PRIsVALUE" is not a %s",
5931 name, type);
5932 VALUE location = rb_const_source_location_at(cbase, id);
5933 if (!NIL_P(location)) {
5934 rb_str_catf(message, "\n%"PRIsVALUE":%"PRIsVALUE":"
5935 " previous definition of %"PRIsVALUE" was here",
5936 rb_ary_entry(location, 0), rb_ary_entry(location, 1), name);
5937 }
5939}
5940
5941static VALUE
5942vm_define_class(ID id, rb_num_t flags, VALUE cbase, VALUE super)
5943{
5944 VALUE klass;
5945
5946 if (VM_DEFINECLASS_HAS_SUPERCLASS_P(flags) && !RB_TYPE_P(super, T_CLASS)) {
5947 rb_raise(rb_eTypeError,
5948 "superclass must be an instance of Class (given an instance of %"PRIsVALUE")",
5949 rb_obj_class(super));
5950 }
5951
5952 vm_check_if_namespace(cbase);
5953
5954 /* find klass */
5955 rb_autoload_load(cbase, id);
5956
5957 if ((klass = vm_const_get_under(id, flags, cbase)) != 0) {
5958 if (!vm_check_if_class(id, flags, super, klass))
5959 unmatched_redefinition("class", cbase, id, klass);
5960 return klass;
5961 }
5962 else {
5963 return vm_declare_class(id, flags, cbase, super);
5964 }
5965}
5966
5967static VALUE
5968vm_define_module(ID id, rb_num_t flags, VALUE cbase)
5969{
5970 VALUE mod;
5971
5972 vm_check_if_namespace(cbase);
5973 if ((mod = vm_const_get_under(id, flags, cbase)) != 0) {
5974 if (!vm_check_if_module(id, mod))
5975 unmatched_redefinition("module", cbase, id, mod);
5976 return mod;
5977 }
5978 else {
5979 return vm_declare_module(id, cbase);
5980 }
5981}
5982
5983static VALUE
5984vm_find_or_create_class_by_id(ID id,
5985 rb_num_t flags,
5986 VALUE cbase,
5987 VALUE super)
5988{
5989 rb_vm_defineclass_type_t type = VM_DEFINECLASS_TYPE(flags);
5990
5991 switch (type) {
5992 case VM_DEFINECLASS_TYPE_CLASS:
5993 /* classdef returns class scope value */
5994 return vm_define_class(id, flags, cbase, super);
5995
5996 case VM_DEFINECLASS_TYPE_SINGLETON_CLASS:
5997 /* classdef returns class scope value */
5998 return rb_singleton_class(cbase);
5999
6000 case VM_DEFINECLASS_TYPE_MODULE:
6001 /* classdef returns class scope value */
6002 return vm_define_module(id, flags, cbase);
6003
6004 default:
6005 rb_bug("unknown defineclass type: %d", (int)type);
6006 }
6007}
6008
6009static rb_method_visibility_t
6010vm_scope_visibility_get(const rb_execution_context_t *ec)
6011{
6012 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
6013
6014 if (!vm_env_cref_by_cref(cfp->ep)) {
6015 return METHOD_VISI_PUBLIC;
6016 }
6017 else {
6018 return CREF_SCOPE_VISI(vm_ec_cref(ec))->method_visi;
6019 }
6020}
6021
6022static int
6023vm_scope_module_func_check(const rb_execution_context_t *ec)
6024{
6025 const rb_control_frame_t *cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
6026
6027 if (!vm_env_cref_by_cref(cfp->ep)) {
6028 return FALSE;
6029 }
6030 else {
6031 return CREF_SCOPE_VISI(vm_ec_cref(ec))->module_func;
6032 }
6033}
6034
6035static void
6036vm_define_method(const rb_execution_context_t *ec, VALUE obj, ID id, VALUE iseqval, int is_singleton)
6037{
6038 VALUE klass;
6039 rb_method_visibility_t visi;
6040 rb_cref_t *cref = vm_ec_cref(ec);
6041
6042 if (is_singleton) {
6043 klass = rb_singleton_class(obj); /* class and frozen checked in this API */
6044 visi = METHOD_VISI_PUBLIC;
6045 }
6046 else {
6047 klass = CREF_CLASS_FOR_DEFINITION(cref);
6048 visi = vm_scope_visibility_get(ec);
6049 }
6050
6051 if (NIL_P(klass)) {
6052 rb_raise(rb_eTypeError, "no class/module to add method");
6053 }
6054
6055 rb_add_method_iseq(klass, id, (const rb_iseq_t *)iseqval, cref, visi);
6056 // Set max_iv_count on klasses based on number of ivar sets that are in the initialize method
6057 if (id == idInitialize && klass != rb_cObject && RB_TYPE_P(klass, T_CLASS) && (rb_get_alloc_func(klass) == rb_class_allocate_instance)) {
6058 RCLASS_SET_MAX_IV_COUNT(klass, rb_estimate_iv_count(klass, (const rb_iseq_t *)iseqval));
6059 }
6060
6061 if (!is_singleton && vm_scope_module_func_check(ec)) {
6062 klass = rb_singleton_class(klass);
6063 rb_add_method_iseq(klass, id, (const rb_iseq_t *)iseqval, cref, METHOD_VISI_PUBLIC);
6064 }
6065}
6066
6067// Return the untagged block handler:
6068// * If it's VM_BLOCK_HANDLER_NONE, return nil
6069// * If it's an ISEQ or an IFUNC, fetch it from its rb_captured_block
6070// * If it's a PROC or SYMBOL, return it as is
6071static VALUE
6072rb_vm_untag_block_handler(VALUE block_handler)
6073{
6074 if (VM_BLOCK_HANDLER_NONE == block_handler) return Qnil;
6075
6076 switch (vm_block_handler_type(block_handler)) {
6077 case block_handler_type_iseq:
6078 case block_handler_type_ifunc: {
6079 struct rb_captured_block *captured = VM_TAGGED_PTR_REF(block_handler, 0x03);
6080 return captured->code.val;
6081 }
6082 case block_handler_type_proc:
6083 case block_handler_type_symbol:
6084 return block_handler;
6085 default:
6086 rb_bug("rb_vm_untag_block_handler: unreachable");
6087 }
6088}
6089
6090VALUE
6091rb_vm_get_untagged_block_handler(rb_control_frame_t *reg_cfp)
6092{
6093 return rb_vm_untag_block_handler(VM_CF_BLOCK_HANDLER(reg_cfp));
6094}
6095
6096static VALUE
6097vm_invokeblock_i(struct rb_execution_context_struct *ec,
6098 struct rb_control_frame_struct *reg_cfp,
6099 struct rb_calling_info *calling)
6100{
6101 const struct rb_callinfo *ci = calling->cd->ci;
6102 VALUE block_handler = VM_CF_BLOCK_HANDLER(GET_CFP());
6103
6104 if (block_handler == VM_BLOCK_HANDLER_NONE) {
6105 rb_vm_localjump_error("no block given (yield)", Qnil, 0);
6106 }
6107 else {
6108 return vm_invoke_block(ec, GET_CFP(), calling, ci, false, block_handler);
6109 }
6110}
6111
6112enum method_explorer_type {
6113 mexp_search_method,
6114 mexp_search_invokeblock,
6115 mexp_search_super,
6116};
6117
6118static inline VALUE
6119vm_sendish(
6120 struct rb_execution_context_struct *ec,
6121 struct rb_control_frame_struct *reg_cfp,
6122 struct rb_call_data *cd,
6123 VALUE block_handler,
6124 enum method_explorer_type method_explorer
6125) {
6126 VALUE val = Qundef;
6127 const struct rb_callinfo *ci = cd->ci;
6128 const struct rb_callcache *cc;
6129 int argc = vm_ci_argc(ci);
6130 VALUE recv = TOPN(argc);
6131 struct rb_calling_info calling = {
6132 .block_handler = block_handler,
6133 .kw_splat = IS_ARGS_KW_SPLAT(ci) > 0,
6134 .recv = recv,
6135 .argc = argc,
6136 .cd = cd,
6137 };
6138
6139 switch (method_explorer) {
6140 case mexp_search_method:
6141 calling.cc = cc = vm_search_method_fastpath((VALUE)reg_cfp->iseq, cd, CLASS_OF(recv));
6142 val = vm_cc_call(cc)(ec, GET_CFP(), &calling);
6143 break;
6144 case mexp_search_super:
6145 calling.cc = cc = vm_search_super_method(reg_cfp, cd, recv);
6146 val = vm_cc_call(cc)(ec, GET_CFP(), &calling);
6147 break;
6148 case mexp_search_invokeblock:
6149 val = vm_invokeblock_i(ec, GET_CFP(), &calling);
6150 break;
6151 }
6152 return val;
6153}
6154
6155VALUE
6156rb_vm_send(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6157{
6158 stack_check(ec);
6159 VALUE bh = vm_caller_setup_arg_block(ec, GET_CFP(), cd->ci, blockiseq, false);
6160 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_method);
6161 VM_EXEC(ec, val);
6162 return val;
6163}
6164
6165VALUE
6166rb_vm_sendforward(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6167{
6168 stack_check(ec);
6169
6170 struct rb_forwarding_call_data adjusted_cd;
6171 struct rb_callinfo adjusted_ci;
6172
6173 VALUE bh = vm_caller_setup_fwd_args(GET_EC(), GET_CFP(), cd, blockiseq, false, &adjusted_cd, &adjusted_ci);
6174
6175 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd.cd, bh, mexp_search_method);
6176
6177 if (cd->cc != adjusted_cd.cd.cc && vm_cc_markable(adjusted_cd.cd.cc)) {
6178 RB_OBJ_WRITE(GET_ISEQ(), &cd->cc, adjusted_cd.cd.cc);
6179 }
6180
6181 VM_EXEC(ec, val);
6182 return val;
6183}
6184
6185VALUE
6186rb_vm_opt_send_without_block(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd)
6187{
6188 stack_check(ec);
6189 VALUE bh = VM_BLOCK_HANDLER_NONE;
6190 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_method);
6191 VM_EXEC(ec, val);
6192 return val;
6193}
6194
6195VALUE
6196rb_vm_invokesuper(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6197{
6198 stack_check(ec);
6199
6200 struct rb_callinfo adjusted_ci = VM_CI_ON_STACK(vm_ci_mid(cd->ci),
6201 vm_ci_flag(cd->ci),
6202 vm_ci_argc(cd->ci),
6203 vm_ci_kwarg(cd->ci));
6204 const struct rb_callcache *original_cc = rbimpl_atomic_ptr_load((void **)&cd->cc, RBIMPL_ATOMIC_ACQUIRE);
6205 struct rb_call_data adjusted_cd = {
6206 .ci = &adjusted_ci,
6207 .cc = original_cc,
6208 };
6209
6210 VALUE bh = vm_caller_setup_arg_block(ec, GET_CFP(), adjusted_cd.ci, blockiseq, true);
6211 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd, bh, mexp_search_super);
6212
6213 if (original_cc != adjusted_cd.cc && vm_cc_markable(adjusted_cd.cc)) {
6214 rbimpl_atomic_ptr_store((volatile void **)&cd->cc, (void *)adjusted_cd.cc, RBIMPL_ATOMIC_RELEASE);
6215 RB_OBJ_WRITTEN(GET_ISEQ(), Qundef, adjusted_cd.cc);
6216 }
6217
6218 VM_EXEC(ec, val);
6219 return val;
6220}
6221
6222VALUE
6223rb_vm_invokesuperforward(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd, ISEQ blockiseq)
6224{
6225 stack_check(ec);
6226 struct rb_forwarding_call_data adjusted_cd;
6227 struct rb_callinfo adjusted_ci;
6228
6229 VALUE bh = vm_caller_setup_fwd_args(GET_EC(), GET_CFP(), cd, blockiseq, true, &adjusted_cd, &adjusted_ci);
6230
6231 VALUE val = vm_sendish(ec, GET_CFP(), &adjusted_cd.cd, bh, mexp_search_super);
6232
6233 if (cd->cc != adjusted_cd.cd.cc && vm_cc_markable(adjusted_cd.cd.cc)) {
6234 RB_OBJ_WRITE(GET_ISEQ(), &cd->cc, adjusted_cd.cd.cc);
6235 }
6236
6237 VM_EXEC(ec, val);
6238 return val;
6239}
6240
6241VALUE
6242rb_vm_invokeblock(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, CALL_DATA cd)
6243{
6244 stack_check(ec);
6245 VALUE bh = VM_BLOCK_HANDLER_NONE;
6246 VALUE val = vm_sendish(ec, GET_CFP(), cd, bh, mexp_search_invokeblock);
6247 VM_EXEC(ec, val);
6248 return val;
6249}
6250
6251/* object.c */
6252VALUE rb_nil_to_s(VALUE);
6253VALUE rb_true_to_s(VALUE);
6254VALUE rb_false_to_s(VALUE);
6255/* numeric.c */
6256VALUE rb_int_to_s(int argc, VALUE *argv, VALUE x);
6257VALUE rb_fix_to_s(VALUE);
6258/* variable.c */
6259VALUE rb_mod_to_s(VALUE);
6261
6262static VALUE
6263vm_objtostring(const rb_iseq_t *iseq, VALUE recv, CALL_DATA cd)
6264{
6265 int type = TYPE(recv);
6266 if (type == T_STRING) {
6267 return recv;
6268 }
6269
6270 const struct rb_callable_method_entry_struct *cme = vm_search_method((VALUE)iseq, cd, recv);
6271
6272 switch (type) {
6273 case T_SYMBOL:
6274 if (check_method_basic_definition(cme)) {
6275 // rb_sym_to_s() allocates a mutable string, but since we are only
6276 // going to use this string for interpolation, it's fine to use the
6277 // frozen string.
6278 return rb_sym2str(recv);
6279 }
6280 break;
6281 case T_MODULE:
6282 case T_CLASS:
6283 if (check_cfunc(cme, rb_mod_to_s)) {
6284 // rb_mod_to_s() allocates a mutable string, but since we are only
6285 // going to use this string for interpolation, it's fine to use the
6286 // frozen string.
6287 VALUE val = rb_mod_name(recv);
6288 if (NIL_P(val)) {
6289 val = rb_mod_to_s(recv);
6290 }
6291 return val;
6292 }
6293 break;
6294 case T_NIL:
6295 if (check_cfunc(cme, rb_nil_to_s)) {
6296 return rb_nil_to_s(recv);
6297 }
6298 break;
6299 case T_TRUE:
6300 if (check_cfunc(cme, rb_true_to_s)) {
6301 return rb_true_to_s(recv);
6302 }
6303 break;
6304 case T_FALSE:
6305 if (check_cfunc(cme, rb_false_to_s)) {
6306 return rb_false_to_s(recv);
6307 }
6308 break;
6309 case T_FIXNUM:
6310 if (check_cfunc(cme, rb_int_to_s)) {
6311 return rb_fix_to_s(recv);
6312 }
6313 break;
6314 }
6315 return Qundef;
6316}
6317
6318// ZJIT implementation is using the C function
6319// and needs to call a non-static function
6320VALUE
6321rb_vm_objtostring(const rb_iseq_t *iseq, VALUE recv, CALL_DATA cd)
6322{
6323 return vm_objtostring(iseq, recv, cd);
6324}
6325
6326static VALUE
6327vm_opt_ary_freeze(VALUE ary, int bop, ID id)
6328{
6329 if (BASIC_OP_UNREDEFINED_P(bop, ARRAY_REDEFINED_OP_FLAG)) {
6330 return ary;
6331 }
6332 else {
6333 return Qundef;
6334 }
6335}
6336
6337static VALUE
6338vm_opt_hash_freeze(VALUE hash, int bop, ID id)
6339{
6340 if (BASIC_OP_UNREDEFINED_P(bop, HASH_REDEFINED_OP_FLAG)) {
6341 return hash;
6342 }
6343 else {
6344 return Qundef;
6345 }
6346}
6347
6348static VALUE
6349vm_opt_str_freeze(VALUE str, int bop, ID id)
6350{
6351 if (BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
6352 return str;
6353 }
6354 else {
6355 return Qundef;
6356 }
6357}
6358
6359/* this macro is mandatory to use OPTIMIZED_CMP. What a design! */
6360#define id_cmp idCmp
6361
6362static VALUE
6363vm_opt_duparray_include_p(rb_execution_context_t *ec, const VALUE ary, VALUE target)
6364{
6365 if (BASIC_OP_UNREDEFINED_P(BOP_INCLUDE_P, ARRAY_REDEFINED_OP_FLAG)) {
6366 return rb_ary_includes(ary, target);
6367 }
6368 else {
6369 VALUE args[1] = {target};
6370
6371 // duparray
6372 RUBY_DTRACE_CREATE_HOOK(ARRAY, RARRAY_LEN(ary));
6373 VALUE dupary = rb_ary_resurrect(ary);
6374
6375 return rb_vm_call_with_refinements(ec, dupary, idIncludeP, 1, args, RB_NO_KEYWORDS);
6376 }
6377}
6378
6379VALUE
6380rb_vm_opt_duparray_include_p(rb_execution_context_t *ec, const VALUE ary, VALUE target)
6381{
6382 return vm_opt_duparray_include_p(ec, ary, target);
6383}
6384
6385static VALUE
6386vm_opt_newarray_max(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr)
6387{
6388 if (BASIC_OP_UNREDEFINED_P(BOP_MAX, ARRAY_REDEFINED_OP_FLAG)) {
6389 if (array_len == 0) {
6390 return Qnil;
6391 }
6392 else {
6393 VALUE result = *ptr;
6394 rb_snum_t i = array_len - 1;
6395 while (i-- > 0) {
6396 const VALUE v = *++ptr;
6397 if (OPTIMIZED_CMP(v, result) > 0) {
6398 result = v;
6399 }
6400 }
6401 return result;
6402 }
6403 }
6404 else {
6405 return rb_vm_call_with_refinements(ec, rb_ary_new4(array_len, ptr), idMax, 0, NULL, RB_NO_KEYWORDS);
6406 }
6407}
6408
6409VALUE
6410rb_vm_opt_newarray_max(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr)
6411{
6412 return vm_opt_newarray_max(ec, array_len, ptr);
6413}
6414
6415static VALUE
6416vm_opt_newarray_min(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr)
6417{
6418 if (BASIC_OP_UNREDEFINED_P(BOP_MIN, ARRAY_REDEFINED_OP_FLAG)) {
6419 if (array_len == 0) {
6420 return Qnil;
6421 }
6422 else {
6423 VALUE result = *ptr;
6424 rb_snum_t i = array_len - 1;
6425 while (i-- > 0) {
6426 const VALUE v = *++ptr;
6427 if (OPTIMIZED_CMP(v, result) < 0) {
6428 result = v;
6429 }
6430 }
6431 return result;
6432 }
6433 }
6434 else {
6435 return rb_vm_call_with_refinements(ec, rb_ary_new4(array_len, ptr), idMin, 0, NULL, RB_NO_KEYWORDS);
6436 }
6437}
6438
6439VALUE
6440rb_vm_opt_newarray_min(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr)
6441{
6442 return vm_opt_newarray_min(ec, array_len, ptr);
6443}
6444
6445static VALUE
6446vm_opt_newarray_hash(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr)
6447{
6448 // If Array#hash is _not_ monkeypatched, use the optimized call
6449 if (BASIC_OP_UNREDEFINED_P(BOP_HASH, ARRAY_REDEFINED_OP_FLAG)) {
6450 return rb_ary_hash_values(array_len, ptr);
6451 }
6452 else {
6453 return rb_vm_call_with_refinements(ec, rb_ary_new4(array_len, ptr), idHash, 0, NULL, RB_NO_KEYWORDS);
6454 }
6455}
6456
6457VALUE
6458rb_vm_opt_newarray_hash(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr)
6459{
6460 return vm_opt_newarray_hash(ec, array_len, ptr);
6461}
6462
6463VALUE rb_setup_fake_ary(struct RArray *fake_ary, const VALUE *list, long len);
6464VALUE rb_ec_pack_ary(rb_execution_context_t *ec, VALUE ary, VALUE fmt, VALUE buffer);
6465
6466static VALUE
6467vm_opt_newarray_include_p(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr, VALUE target)
6468{
6469 if (BASIC_OP_UNREDEFINED_P(BOP_INCLUDE_P, ARRAY_REDEFINED_OP_FLAG)) {
6470 struct RArray fake_ary = {RBASIC_INIT};
6471 VALUE ary = rb_setup_fake_ary(&fake_ary, ptr, array_len);
6472 return rb_ary_includes(ary, target);
6473 }
6474 else {
6475 VALUE args[1] = {target};
6476 return rb_vm_call_with_refinements(ec, rb_ary_new4(array_len, ptr), idIncludeP, 1, args, RB_NO_KEYWORDS);
6477 }
6478}
6479
6480VALUE
6481rb_vm_opt_newarray_include_p(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr, VALUE target)
6482{
6483 return vm_opt_newarray_include_p(ec, array_len, ptr, target);
6484}
6485
6486static VALUE
6487vm_opt_newarray_pack_buffer(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr, VALUE fmt, VALUE buffer)
6488{
6489 if (BASIC_OP_UNREDEFINED_P(BOP_PACK, ARRAY_REDEFINED_OP_FLAG)) {
6490 struct RArray fake_ary = {RBASIC_INIT};
6491 VALUE ary = rb_setup_fake_ary(&fake_ary, ptr, array_len);
6492 return rb_ec_pack_ary(ec, ary, fmt, (UNDEF_P(buffer) ? Qnil : buffer));
6493 }
6494 else {
6495 // The opt_newarray_send insn drops the keyword args so we need to rebuild them.
6496 // Setup an array with room for keyword hash.
6497 VALUE args[2];
6498 args[0] = fmt;
6499 int kw_splat = RB_NO_KEYWORDS;
6500 int argc = 1;
6501
6502 if (!UNDEF_P(buffer)) {
6503 args[1] = rb_hash_new_with_size(1);
6504 rb_hash_aset(args[1], ID2SYM(idBuffer), buffer);
6505 kw_splat = RB_PASS_KEYWORDS;
6506 argc++;
6507 }
6508
6509 return rb_vm_call_with_refinements(ec, rb_ary_new4(array_len, ptr), idPack, argc, args, kw_splat);
6510 }
6511}
6512
6513VALUE
6514rb_vm_opt_newarray_pack_buffer(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr, VALUE fmt, VALUE buffer)
6515{
6516 return vm_opt_newarray_pack_buffer(ec, array_len, ptr, fmt, buffer);
6517}
6518
6519VALUE
6520rb_vm_opt_newarray_pack(rb_execution_context_t *ec, rb_num_t array_len, const VALUE *ptr, VALUE fmt)
6521{
6522 return vm_opt_newarray_pack_buffer(ec, array_len, ptr, fmt, Qundef);
6523}
6524
6525#undef id_cmp
6526
6527static void
6528vm_track_constant_cache(ID id, void *ic)
6529{
6530 rb_vm_t *vm = GET_VM();
6531 struct rb_id_table *const_cache = vm->constant_cache;
6532 VALUE lookup_result;
6533 set_table *ics;
6534
6535 if (rb_id_table_lookup(const_cache, id, &lookup_result)) {
6536 ics = (set_table *)lookup_result;
6537 }
6538 else {
6539 ics = set_init_numtable();
6540 rb_id_table_insert(const_cache, id, (VALUE)ics);
6541 }
6542
6543 /* The call below to st_insert could allocate which could trigger a GC.
6544 * If it triggers a GC, it may free an iseq that also holds a cache to this
6545 * constant. If that iseq is the last iseq with a cache to this constant, then
6546 * it will free this ST table, which would cause an use-after-free during this
6547 * st_insert.
6548 *
6549 * So to fix this issue, we store the ID that is currently being inserted
6550 * and, in remove_from_constant_cache, we don't free the ST table for ID
6551 * equal to this one.
6552 *
6553 * See [Bug #20921].
6554 */
6555 vm->inserting_constant_cache_id = id;
6556
6557 set_insert(ics, (st_data_t)ic);
6558
6559 vm->inserting_constant_cache_id = (ID)0;
6560}
6561
6562static void
6563vm_ic_track_const_chain(rb_control_frame_t *cfp, IC ic, const ID *segments)
6564{
6565 RB_VM_LOCKING() {
6566 for (int i = 0; segments[i]; i++) {
6567 ID id = segments[i];
6568 if (id == idNULL) continue;
6569 vm_track_constant_cache(id, ic);
6570 }
6571 }
6572}
6573
6574// For JIT inlining
6575static inline bool
6576vm_inlined_ic_hit_p(VALUE flags, VALUE value, const rb_cref_t *ic_cref, const VALUE *reg_ep)
6577{
6578 if ((flags & IMEMO_CONST_CACHE_SHAREABLE) || rb_ractor_main_p()) {
6579 VM_ASSERT(ractor_incidental_shareable_p(flags & IMEMO_CONST_CACHE_SHAREABLE, value));
6580
6581 return (ic_cref == NULL || // no need to check CREF
6582 ic_cref == vm_get_cref(reg_ep));
6583 }
6584 return false;
6585}
6586
6587static bool
6588vm_ic_hit_p(const struct iseq_inline_constant_cache_entry *ice, const VALUE *reg_ep)
6589{
6590 VM_ASSERT(IMEMO_TYPE_P(ice, imemo_constcache));
6591 return vm_inlined_ic_hit_p(ice->flags, ice->value, ice->ic_cref, reg_ep);
6592}
6593
6594// YJIT needs this function to never allocate and never raise
6595bool
6596rb_vm_ic_hit_p(IC ic, const VALUE *reg_ep)
6597{
6598 return ic->entry && vm_ic_hit_p(ic->entry, reg_ep);
6599}
6600
6601static void
6602vm_ic_update(const rb_iseq_t *iseq, IC ic, VALUE val, const VALUE *reg_ep, const VALUE *pc)
6603{
6604 if (ruby_vm_const_missing_count > 0) {
6605 ruby_vm_const_missing_count = 0;
6606 ic->entry = NULL;
6607 return;
6608 }
6609
6610 struct iseq_inline_constant_cache_entry *ice = SHAREABLE_IMEMO_NEW(struct iseq_inline_constant_cache_entry, imemo_constcache, 0);
6611 RB_OBJ_WRITE(ice, &ice->value, val);
6612 ice->ic_cref = vm_get_const_key_cref(reg_ep);
6613
6614 if (rb_ractor_shareable_p(val)) {
6615 RUBY_ASSERT((rb_gc_verify_shareable(val), 1));
6616 ice->flags |= IMEMO_CONST_CACHE_SHAREABLE;
6617 }
6618 RB_OBJ_WRITE(iseq, &ic->entry, ice);
6619 RUBY_ASSERT(pc >= ISEQ_BODY(iseq)->iseq_encoded);
6620 unsigned pos = (unsigned)(pc - ISEQ_BODY(iseq)->iseq_encoded);
6621 rb_yjit_constant_ic_update(iseq, ic, pos);
6622}
6623
6624VALUE
6625rb_vm_opt_getconstant_path(rb_execution_context_t *ec, rb_control_frame_t *const reg_cfp, IC ic)
6626{
6627 VALUE val;
6628 const ID *segments = ic->segments;
6629 struct iseq_inline_constant_cache_entry *ice = ic->entry;
6630
6631 if (ice && vm_ic_hit_p(ice, GET_EP())) {
6632 val = ice->value;
6633
6634 VM_ASSERT(val == vm_get_ev_const_chain(ec, segments));
6635 }
6636 else {
6637 ruby_vm_constant_cache_misses++;
6638 val = vm_get_ev_const_chain(ec, segments);
6639 vm_ic_track_const_chain(GET_CFP(), ic, segments);
6640 // Undo the PC increment to get the address to this instruction
6641 // INSN_ATTR(width) == 2
6642 vm_ic_update(GET_ISEQ(), ic, val, GET_EP(), GET_PC() - 2);
6643 }
6644 return val;
6645}
6646
6647static VALUE
6648vm_once_dispatch(rb_execution_context_t *ec, ISEQ iseq, ISE is)
6649{
6650 rb_thread_t *th = rb_ec_thread_ptr(ec);
6651 rb_thread_t *const RUNNING_THREAD_ONCE_DONE = (rb_thread_t *)(0x1);
6652
6653 again:
6654 if (is->once.running_thread == RUNNING_THREAD_ONCE_DONE) {
6655 return is->once.value;
6656 }
6657 else if (is->once.running_thread == NULL) {
6658 VALUE val;
6659 is->once.running_thread = th;
6660 val = rb_ensure(vm_once_exec, (VALUE)iseq, vm_once_clear, (VALUE)is);
6661 // TODO: confirm that it is shareable
6662
6663 if (RB_FL_ABLE(val)) {
6664 RB_OBJ_SET_SHAREABLE(val);
6665 }
6666
6667 RB_OBJ_WRITE(ec->cfp->iseq, &is->once.value, val);
6668
6669 /* is->once.running_thread is cleared by vm_once_clear() */
6670 is->once.running_thread = RUNNING_THREAD_ONCE_DONE; /* success */
6671 return val;
6672 }
6673 else if (is->once.running_thread == th) {
6674 /* recursive once */
6675 return vm_once_exec((VALUE)iseq);
6676 }
6677 else {
6678 /* waiting for finish */
6679 RUBY_VM_CHECK_INTS(ec);
6681 goto again;
6682 }
6683}
6684
6685static OFFSET
6686vm_case_dispatch(CDHASH hash, OFFSET else_offset, VALUE key)
6687{
6688 switch (OBJ_BUILTIN_TYPE(key)) {
6689 case -1:
6690 case T_FLOAT:
6691 case T_SYMBOL:
6692 case T_BIGNUM:
6693 case T_STRING:
6694 if (BASIC_OP_UNREDEFINED_P(BOP_EQQ,
6695 SYMBOL_REDEFINED_OP_FLAG |
6696 INTEGER_REDEFINED_OP_FLAG |
6697 FLOAT_REDEFINED_OP_FLAG |
6698 NIL_REDEFINED_OP_FLAG |
6699 TRUE_REDEFINED_OP_FLAG |
6700 FALSE_REDEFINED_OP_FLAG |
6701 STRING_REDEFINED_OP_FLAG)) {
6702 st_data_t val;
6703 if (RB_FLOAT_TYPE_P(key)) {
6704 double kval = RFLOAT_VALUE(key);
6705 if (!isinf(kval) && modf(kval, &kval) == 0.0) {
6706 key = FIXABLE(kval) ? LONG2FIX((long)kval) : rb_dbl2big(kval);
6707 }
6708 }
6709 if (rb_hash_stlike_lookup(hash, key, &val)) {
6710 return FIX2LONG((VALUE)val);
6711 }
6712 else {
6713 return else_offset;
6714 }
6715 }
6716 }
6717 return 0;
6718}
6719
6720NORETURN(static void
6721 vm_stack_consistency_error(const rb_execution_context_t *ec,
6722 const rb_control_frame_t *,
6723 const VALUE *));
6724static void
6725vm_stack_consistency_error(const rb_execution_context_t *ec,
6726 const rb_control_frame_t *cfp,
6727 const VALUE *bp)
6728{
6729 const ptrdiff_t nsp = VM_SP_CNT(ec, cfp->sp);
6730 const ptrdiff_t nbp = VM_SP_CNT(ec, bp);
6731 static const char stack_consistency_error[] =
6732 "Stack consistency error (sp: %"PRIdPTRDIFF", bp: %"PRIdPTRDIFF")";
6733#if defined RUBY_DEVEL
6734 VALUE mesg = rb_sprintf(stack_consistency_error, nsp, nbp);
6735 rb_str_cat_cstr(mesg, "\n");
6736 rb_str_append(mesg, rb_iseq_disasm(cfp->iseq));
6738#else
6739 rb_bug(stack_consistency_error, nsp, nbp);
6740#endif
6741}
6742
6743static VALUE
6744vm_opt_plus(VALUE recv, VALUE obj)
6745{
6746 if (FIXNUM_2_P(recv, obj) &&
6747 BASIC_OP_UNREDEFINED_P(BOP_PLUS, INTEGER_REDEFINED_OP_FLAG)) {
6748 return rb_fix_plus_fix(recv, obj);
6749 }
6750 else if (FLONUM_2_P(recv, obj) &&
6751 BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
6752 return DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
6753 }
6754 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6755 return Qundef;
6756 }
6757 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6758 RBASIC_CLASS(obj) == rb_cFloat &&
6759 BASIC_OP_UNREDEFINED_P(BOP_PLUS, FLOAT_REDEFINED_OP_FLAG)) {
6760 return DBL2NUM(RFLOAT_VALUE(recv) + RFLOAT_VALUE(obj));
6761 }
6762 else if (RBASIC_CLASS(recv) == rb_cString &&
6763 RBASIC_CLASS(obj) == rb_cString &&
6764 BASIC_OP_UNREDEFINED_P(BOP_PLUS, STRING_REDEFINED_OP_FLAG)) {
6765 return rb_str_opt_plus(recv, obj);
6766 }
6767 else if (RBASIC_CLASS(recv) == rb_cArray &&
6768 RBASIC_CLASS(obj) == rb_cArray &&
6769 BASIC_OP_UNREDEFINED_P(BOP_PLUS, ARRAY_REDEFINED_OP_FLAG)) {
6770 return rb_ary_plus(recv, obj);
6771 }
6772 else {
6773 return Qundef;
6774 }
6775}
6776
6777static VALUE
6778vm_opt_minus(VALUE recv, VALUE obj)
6779{
6780 if (FIXNUM_2_P(recv, obj) &&
6781 BASIC_OP_UNREDEFINED_P(BOP_MINUS, INTEGER_REDEFINED_OP_FLAG)) {
6782 return rb_fix_minus_fix(recv, obj);
6783 }
6784 else if (FLONUM_2_P(recv, obj) &&
6785 BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
6786 return DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
6787 }
6788 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6789 return Qundef;
6790 }
6791 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6792 RBASIC_CLASS(obj) == rb_cFloat &&
6793 BASIC_OP_UNREDEFINED_P(BOP_MINUS, FLOAT_REDEFINED_OP_FLAG)) {
6794 return DBL2NUM(RFLOAT_VALUE(recv) - RFLOAT_VALUE(obj));
6795 }
6796 else {
6797 return Qundef;
6798 }
6799}
6800
6801static VALUE
6802vm_opt_mult(VALUE recv, VALUE obj)
6803{
6804 if (FIXNUM_2_P(recv, obj) &&
6805 BASIC_OP_UNREDEFINED_P(BOP_MULT, INTEGER_REDEFINED_OP_FLAG)) {
6806 return rb_fix_mul_fix(recv, obj);
6807 }
6808 else if (FLONUM_2_P(recv, obj) &&
6809 BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
6810 return DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
6811 }
6812 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6813 return Qundef;
6814 }
6815 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6816 RBASIC_CLASS(obj) == rb_cFloat &&
6817 BASIC_OP_UNREDEFINED_P(BOP_MULT, FLOAT_REDEFINED_OP_FLAG)) {
6818 return DBL2NUM(RFLOAT_VALUE(recv) * RFLOAT_VALUE(obj));
6819 }
6820 else {
6821 return Qundef;
6822 }
6823}
6824
6825static VALUE
6826vm_opt_div(VALUE recv, VALUE obj)
6827{
6828 if (FIXNUM_2_P(recv, obj) &&
6829 BASIC_OP_UNREDEFINED_P(BOP_DIV, INTEGER_REDEFINED_OP_FLAG)) {
6830 return (FIX2LONG(obj) == 0) ? Qundef : rb_fix_div_fix(recv, obj);
6831 }
6832 else if (FLONUM_2_P(recv, obj) &&
6833 BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
6834 return rb_flo_div_flo(recv, obj);
6835 }
6836 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6837 return Qundef;
6838 }
6839 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6840 RBASIC_CLASS(obj) == rb_cFloat &&
6841 BASIC_OP_UNREDEFINED_P(BOP_DIV, FLOAT_REDEFINED_OP_FLAG)) {
6842 return rb_flo_div_flo(recv, obj);
6843 }
6844 else {
6845 return Qundef;
6846 }
6847}
6848
6849static VALUE
6850vm_opt_mod(VALUE recv, VALUE obj)
6851{
6852 if (FIXNUM_2_P(recv, obj) &&
6853 BASIC_OP_UNREDEFINED_P(BOP_MOD, INTEGER_REDEFINED_OP_FLAG)) {
6854 return (FIX2LONG(obj) == 0) ? Qundef : rb_fix_mod_fix(recv, obj);
6855 }
6856 else if (FLONUM_2_P(recv, obj) &&
6857 BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
6858 return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
6859 }
6860 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6861 return Qundef;
6862 }
6863 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6864 RBASIC_CLASS(obj) == rb_cFloat &&
6865 BASIC_OP_UNREDEFINED_P(BOP_MOD, FLOAT_REDEFINED_OP_FLAG)) {
6866 return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(recv), RFLOAT_VALUE(obj)));
6867 }
6868 else {
6869 return Qundef;
6870 }
6871}
6872
6873static VALUE
6874vm_opt_neq(const rb_iseq_t *iseq, CALL_DATA cd, CALL_DATA cd_eq, VALUE recv, VALUE obj)
6875{
6876 if (vm_method_cfunc_is(iseq, cd, recv, rb_obj_not_equal)) {
6877 VALUE val = opt_equality(iseq, recv, obj, cd_eq);
6878
6879 if (!UNDEF_P(val)) {
6880 return RBOOL(!RTEST(val));
6881 }
6882 }
6883
6884 return Qundef;
6885}
6886
6887static VALUE
6888vm_opt_lt(VALUE recv, VALUE obj)
6889{
6890 if (FIXNUM_2_P(recv, obj) &&
6891 BASIC_OP_UNREDEFINED_P(BOP_LT, INTEGER_REDEFINED_OP_FLAG)) {
6892 return RBOOL((SIGNED_VALUE)recv < (SIGNED_VALUE)obj);
6893 }
6894 else if (FLONUM_2_P(recv, obj) &&
6895 BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
6896 return RBOOL(RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj));
6897 }
6898 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6899 return Qundef;
6900 }
6901 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6902 RBASIC_CLASS(obj) == rb_cFloat &&
6903 BASIC_OP_UNREDEFINED_P(BOP_LT, FLOAT_REDEFINED_OP_FLAG)) {
6904 return RBOOL(RFLOAT_VALUE(recv) < RFLOAT_VALUE(obj));
6905 }
6906 else {
6907 return Qundef;
6908 }
6909}
6910
6911static VALUE
6912vm_opt_le(VALUE recv, VALUE obj)
6913{
6914 if (FIXNUM_2_P(recv, obj) &&
6915 BASIC_OP_UNREDEFINED_P(BOP_LE, INTEGER_REDEFINED_OP_FLAG)) {
6916 return RBOOL((SIGNED_VALUE)recv <= (SIGNED_VALUE)obj);
6917 }
6918 else if (FLONUM_2_P(recv, obj) &&
6919 BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
6920 return RBOOL(RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj));
6921 }
6922 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6923 return Qundef;
6924 }
6925 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6926 RBASIC_CLASS(obj) == rb_cFloat &&
6927 BASIC_OP_UNREDEFINED_P(BOP_LE, FLOAT_REDEFINED_OP_FLAG)) {
6928 return RBOOL(RFLOAT_VALUE(recv) <= RFLOAT_VALUE(obj));
6929 }
6930 else {
6931 return Qundef;
6932 }
6933}
6934
6935static VALUE
6936vm_opt_gt(VALUE recv, VALUE obj)
6937{
6938 if (FIXNUM_2_P(recv, obj) &&
6939 BASIC_OP_UNREDEFINED_P(BOP_GT, INTEGER_REDEFINED_OP_FLAG)) {
6940 return RBOOL((SIGNED_VALUE)recv > (SIGNED_VALUE)obj);
6941 }
6942 else if (FLONUM_2_P(recv, obj) &&
6943 BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
6944 return RBOOL(RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj));
6945 }
6946 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6947 return Qundef;
6948 }
6949 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6950 RBASIC_CLASS(obj) == rb_cFloat &&
6951 BASIC_OP_UNREDEFINED_P(BOP_GT, FLOAT_REDEFINED_OP_FLAG)) {
6952 return RBOOL(RFLOAT_VALUE(recv) > RFLOAT_VALUE(obj));
6953 }
6954 else {
6955 return Qundef;
6956 }
6957}
6958
6959static VALUE
6960vm_opt_ge(VALUE recv, VALUE obj)
6961{
6962 if (FIXNUM_2_P(recv, obj) &&
6963 BASIC_OP_UNREDEFINED_P(BOP_GE, INTEGER_REDEFINED_OP_FLAG)) {
6964 return RBOOL((SIGNED_VALUE)recv >= (SIGNED_VALUE)obj);
6965 }
6966 else if (FLONUM_2_P(recv, obj) &&
6967 BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
6968 return RBOOL(RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj));
6969 }
6970 else if (SPECIAL_CONST_P(recv) || SPECIAL_CONST_P(obj)) {
6971 return Qundef;
6972 }
6973 else if (RBASIC_CLASS(recv) == rb_cFloat &&
6974 RBASIC_CLASS(obj) == rb_cFloat &&
6975 BASIC_OP_UNREDEFINED_P(BOP_GE, FLOAT_REDEFINED_OP_FLAG)) {
6976 return RBOOL(RFLOAT_VALUE(recv) >= RFLOAT_VALUE(obj));
6977 }
6978 else {
6979 return Qundef;
6980 }
6981}
6982
6983
6984static VALUE
6985vm_opt_ltlt(VALUE recv, VALUE obj)
6986{
6987 if (SPECIAL_CONST_P(recv)) {
6988 return Qundef;
6989 }
6990 else if (RBASIC_CLASS(recv) == rb_cString &&
6991 BASIC_OP_UNREDEFINED_P(BOP_LTLT, STRING_REDEFINED_OP_FLAG)) {
6992 if (LIKELY(RB_TYPE_P(obj, T_STRING))) {
6993 return rb_str_buf_append(recv, obj);
6994 }
6995 else {
6996 return rb_str_concat(recv, obj);
6997 }
6998 }
6999 else if (RBASIC_CLASS(recv) == rb_cArray &&
7000 BASIC_OP_UNREDEFINED_P(BOP_LTLT, ARRAY_REDEFINED_OP_FLAG)) {
7001 return rb_ary_push(recv, obj);
7002 }
7003 else {
7004 return Qundef;
7005 }
7006}
7007
7008static VALUE
7009vm_opt_and(VALUE recv, VALUE obj)
7010{
7011 // If recv and obj are both fixnums, then the bottom tag bit
7012 // will be 1 on both. 1 & 1 == 1, so the result value will also
7013 // be a fixnum. If either side is *not* a fixnum, then the tag bit
7014 // will be 0, and we return Qundef.
7015 VALUE ret = ((SIGNED_VALUE) recv) & ((SIGNED_VALUE) obj);
7016
7017 if (FIXNUM_P(ret) &&
7018 BASIC_OP_UNREDEFINED_P(BOP_AND, INTEGER_REDEFINED_OP_FLAG)) {
7019 return ret;
7020 }
7021 else {
7022 return Qundef;
7023 }
7024}
7025
7026static VALUE
7027vm_opt_or(VALUE recv, VALUE obj)
7028{
7029 if (FIXNUM_2_P(recv, obj) &&
7030 BASIC_OP_UNREDEFINED_P(BOP_OR, INTEGER_REDEFINED_OP_FLAG)) {
7031 return recv | obj;
7032 }
7033 else {
7034 return Qundef;
7035 }
7036}
7037
7038static VALUE
7039vm_opt_aref(VALUE recv, VALUE obj)
7040{
7041 if (SPECIAL_CONST_P(recv)) {
7042 if (FIXNUM_2_P(recv, obj) &&
7043 BASIC_OP_UNREDEFINED_P(BOP_AREF, INTEGER_REDEFINED_OP_FLAG)) {
7044 return rb_fix_aref(recv, obj);
7045 }
7046 return Qundef;
7047 }
7048 else if (RBASIC_CLASS(recv) == rb_cArray &&
7049 BASIC_OP_UNREDEFINED_P(BOP_AREF, ARRAY_REDEFINED_OP_FLAG)) {
7050 if (FIXNUM_P(obj)) {
7051 return rb_ary_entry_internal(recv, FIX2LONG(obj));
7052 }
7053 else {
7054 return rb_ary_aref1(recv, obj);
7055 }
7056 }
7057 else if (RBASIC_CLASS(recv) == rb_cHash &&
7058 BASIC_OP_UNREDEFINED_P(BOP_AREF, HASH_REDEFINED_OP_FLAG)) {
7059 return rb_hash_aref(recv, obj);
7060 }
7061 else {
7062 return Qundef;
7063 }
7064}
7065
7066static VALUE
7067vm_opt_aset(VALUE recv, VALUE obj, VALUE set)
7068{
7069 if (SPECIAL_CONST_P(recv)) {
7070 return Qundef;
7071 }
7072 else if (RBASIC_CLASS(recv) == rb_cArray &&
7073 BASIC_OP_UNREDEFINED_P(BOP_ASET, ARRAY_REDEFINED_OP_FLAG) &&
7074 FIXNUM_P(obj)) {
7075 rb_ary_store(recv, FIX2LONG(obj), set);
7076 return set;
7077 }
7078 else if (RBASIC_CLASS(recv) == rb_cHash &&
7079 BASIC_OP_UNREDEFINED_P(BOP_ASET, HASH_REDEFINED_OP_FLAG)) {
7080 rb_hash_aset(recv, obj, set);
7081 return set;
7082 }
7083 else {
7084 return Qundef;
7085 }
7086}
7087
7088static VALUE
7089vm_opt_length(VALUE recv, int bop)
7090{
7091 if (SPECIAL_CONST_P(recv)) {
7092 return Qundef;
7093 }
7094 else if (RBASIC_CLASS(recv) == rb_cString &&
7095 BASIC_OP_UNREDEFINED_P(bop, STRING_REDEFINED_OP_FLAG)) {
7096 if (bop == BOP_EMPTY_P) {
7097 return LONG2NUM(RSTRING_LEN(recv));
7098 }
7099 else {
7100 return rb_str_length(recv);
7101 }
7102 }
7103 else if (RBASIC_CLASS(recv) == rb_cArray &&
7104 BASIC_OP_UNREDEFINED_P(bop, ARRAY_REDEFINED_OP_FLAG)) {
7105 return LONG2NUM(RARRAY_LEN(recv));
7106 }
7107 else if (RBASIC_CLASS(recv) == rb_cHash &&
7108 BASIC_OP_UNREDEFINED_P(bop, HASH_REDEFINED_OP_FLAG)) {
7109 return INT2FIX(RHASH_SIZE(recv));
7110 }
7111 else {
7112 return Qundef;
7113 }
7114}
7115
7116static VALUE
7117vm_opt_empty_p(VALUE recv)
7118{
7119 switch (vm_opt_length(recv, BOP_EMPTY_P)) {
7120 case Qundef: return Qundef;
7121 case INT2FIX(0): return Qtrue;
7122 default: return Qfalse;
7123 }
7124}
7125
7126VALUE rb_false(VALUE obj);
7127
7128static VALUE
7129vm_opt_nil_p(const rb_iseq_t *iseq, CALL_DATA cd, VALUE recv)
7130{
7131 if (NIL_P(recv) &&
7132 BASIC_OP_UNREDEFINED_P(BOP_NIL_P, NIL_REDEFINED_OP_FLAG)) {
7133 return Qtrue;
7134 }
7135 else if (vm_method_cfunc_is(iseq, cd, recv, rb_false)) {
7136 return Qfalse;
7137 }
7138 else {
7139 return Qundef;
7140 }
7141}
7142
7143static VALUE
7144fix_succ(VALUE x)
7145{
7146 switch (x) {
7147 case ~0UL:
7148 /* 0xFFFF_FFFF == INT2FIX(-1)
7149 * `-1.succ` is of course 0. */
7150 return INT2FIX(0);
7151 case RSHIFT(~0UL, 1):
7152 /* 0x7FFF_FFFF == LONG2FIX(0x3FFF_FFFF)
7153 * 0x3FFF_FFFF + 1 == 0x4000_0000, which is a Bignum. */
7154 return rb_uint2big(1UL << (SIZEOF_LONG * CHAR_BIT - 2));
7155 default:
7156 /* LONG2FIX(FIX2LONG(x)+FIX2LONG(y))
7157 * == ((lx*2+1)/2 + (ly*2+1)/2)*2+1
7158 * == lx*2 + ly*2 + 1
7159 * == (lx*2+1) + (ly*2+1) - 1
7160 * == x + y - 1
7161 *
7162 * Here, if we put y := INT2FIX(1):
7163 *
7164 * == x + INT2FIX(1) - 1
7165 * == x + 2 .
7166 */
7167 return x + 2;
7168 }
7169}
7170
7171static VALUE
7172vm_opt_succ(VALUE recv)
7173{
7174 if (FIXNUM_P(recv) &&
7175 BASIC_OP_UNREDEFINED_P(BOP_SUCC, INTEGER_REDEFINED_OP_FLAG)) {
7176 return fix_succ(recv);
7177 }
7178 else if (SPECIAL_CONST_P(recv)) {
7179 return Qundef;
7180 }
7181 else if (RBASIC_CLASS(recv) == rb_cString &&
7182 BASIC_OP_UNREDEFINED_P(BOP_SUCC, STRING_REDEFINED_OP_FLAG)) {
7183 return rb_str_succ(recv);
7184 }
7185 else {
7186 return Qundef;
7187 }
7188}
7189
7190static VALUE
7191vm_opt_not(const rb_iseq_t *iseq, CALL_DATA cd, VALUE recv)
7192{
7193 if (vm_method_cfunc_is(iseq, cd, recv, rb_obj_not)) {
7194 return RBOOL(!RTEST(recv));
7195 }
7196 else {
7197 return Qundef;
7198 }
7199}
7200
7201static VALUE
7202vm_opt_regexpmatch2(VALUE recv, VALUE obj)
7203{
7204 if (SPECIAL_CONST_P(recv)) {
7205 return Qundef;
7206 }
7207 else if (RBASIC_CLASS(recv) == rb_cString &&
7208 CLASS_OF(obj) == rb_cRegexp &&
7209 BASIC_OP_UNREDEFINED_P(BOP_MATCH, STRING_REDEFINED_OP_FLAG)) {
7210 return rb_reg_match(obj, recv);
7211 }
7212 else if (RBASIC_CLASS(recv) == rb_cRegexp &&
7213 BASIC_OP_UNREDEFINED_P(BOP_MATCH, REGEXP_REDEFINED_OP_FLAG)) {
7214 return rb_reg_match(recv, obj);
7215 }
7216 else {
7217 return Qundef;
7218 }
7219}
7220
7221rb_event_flag_t rb_iseq_event_flags(const rb_iseq_t *iseq, size_t pos);
7222
7223NOINLINE(static void vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp));
7224
7225static inline void
7226vm_trace_hook(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, const VALUE *pc,
7227 rb_event_flag_t pc_events, rb_event_flag_t target_event,
7228 rb_hook_list_t *global_hooks, rb_hook_list_t *local_hooks, VALUE val)
7229{
7230 rb_event_flag_t event = pc_events & target_event;
7231 VALUE self = GET_SELF();
7232
7233 VM_ASSERT(rb_popcount64((uint64_t)event) == 1);
7234
7235 if (local_hooks) local_hooks->running++; // make sure they don't get deleted while global hooks run
7236
7237 if (event & global_hooks->events) {
7238 /* increment PC because source line is calculated with PC-1 */
7239 reg_cfp->pc++;
7240 vm_dtrace(event, ec);
7241 rb_exec_event_hook_orig(ec, global_hooks, event, self, 0, 0, 0 , val, 0);
7242 reg_cfp->pc--;
7243 }
7244
7245 if (local_hooks) local_hooks->running--;
7246 if (local_hooks != NULL) {
7247 if (event & local_hooks->events) {
7248 /* increment PC because source line is calculated with PC-1 */
7249 reg_cfp->pc++;
7250 rb_exec_event_hook_orig(ec, local_hooks, event, self, 0, 0, 0 , val, 0);
7251 reg_cfp->pc--;
7252 }
7253 }
7254}
7255
7256/* Re-fetch the iseq-local hook list before each event: a hook fired by an
7257 * earlier event at this pc can disable the last targeted TracePoint on this
7258 * iseq, which frees local_hooks. Reload from its stable source (the ractor's
7259 * targeted-hooks table) so we never dereference a dangling pointer. */
7260#define VM_TRACE_HOOK(target_event, val) do { \
7261 if ((pc_events & (target_event)) & enabled_flags) { \
7262 if (local_hooks_cnt > 0) local_hooks = rb_iseq_local_hooks(iseq, r, false); \
7263 vm_trace_hook(ec, reg_cfp, pc, pc_events, (target_event), global_hooks, local_hooks, (val)); \
7264 } \
7265} while (0)
7266
7267static VALUE
7268rescue_errinfo(rb_execution_context_t *ec, rb_control_frame_t *cfp)
7269{
7270 VM_ASSERT(VM_FRAME_RUBYFRAME_P(cfp));
7271 VM_ASSERT(ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_RESCUE);
7272 return cfp->ep[VM_ENV_INDEX_LAST_LVAR];
7273}
7274
7275static void
7276vm_trace(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp)
7277{
7278 const VALUE *pc = reg_cfp->pc;
7279 rb_ractor_t *r = rb_ec_ractor_ptr(ec);
7280 rb_event_flag_t enabled_flags = r->pub.hooks.events & ISEQ_TRACE_EVENTS;
7281 rb_event_flag_t ractor_events = enabled_flags;
7282
7283 if (enabled_flags == 0 && rb_ractor_targeted_hooks_cnt(r) == 0) {
7284 return;
7285 }
7286 else {
7287 const rb_iseq_t *iseq = reg_cfp->iseq;
7288 size_t pos = pc - ISEQ_BODY(iseq)->iseq_encoded;
7289 rb_event_flag_t pc_events = rb_iseq_event_flags(iseq, pos);
7290 unsigned int local_hooks_cnt = iseq->aux.exec.local_hooks_cnt;
7291 rb_hook_list_t *local_hooks = NULL;
7292 if (RB_UNLIKELY(local_hooks_cnt > 0)) {
7293 st_data_t val;
7294 if (st_lookup(rb_ractor_targeted_hooks(r), (st_data_t)iseq, &val)) {
7295 local_hooks = (rb_hook_list_t*)val;
7296 }
7297 }
7298 rb_event_flag_t iseq_local_events = local_hooks != NULL ? local_hooks->events : 0;
7299
7300 rb_hook_list_t *bmethod_local_hooks = NULL;
7301 rb_event_flag_t bmethod_local_events = 0;
7302 unsigned int bmethod_hooks_cnt = 0;
7303 rb_method_definition_t *bmethod_def = NULL;
7304 const bool bmethod_frame = VM_FRAME_BMETHOD_P(reg_cfp);
7305 enabled_flags |= iseq_local_events;
7306
7307 VM_ASSERT((iseq_local_events & ~ISEQ_TRACE_EVENTS) == 0);
7308
7309 if (bmethod_frame) {
7310 const rb_callable_method_entry_t *me = rb_vm_frame_method_entry(reg_cfp);
7311 VM_ASSERT(me->def->type == VM_METHOD_TYPE_BMETHOD);
7312 bmethod_def = me->def;
7313 bmethod_hooks_cnt = me->def->body.bmethod.local_hooks_cnt;
7314 if (RB_UNLIKELY(bmethod_hooks_cnt > 0)) {
7315 st_data_t val;
7316 if (st_lookup(rb_ractor_targeted_hooks(r), (st_data_t)me->def, &val)) {
7317 bmethod_local_hooks = (rb_hook_list_t*)val;
7318 }
7319 if (bmethod_local_hooks) {
7320 bmethod_local_events = bmethod_local_hooks->events;
7321 }
7322 }
7323 }
7324
7325 if ((pc_events & enabled_flags) == 0 && !bmethod_frame) {
7326#if 0
7327 /* disable trace */
7328 /* TODO: incomplete */
7329 rb_iseq_trace_set(iseq, vm_event_flags & ISEQ_TRACE_EVENTS);
7330#else
7331 /* do not disable trace because of performance problem
7332 * (re-enable overhead)
7333 */
7334#endif
7335 return;
7336 }
7337 else if (ec->trace_arg != NULL) {
7338 /* already tracing */
7339 return;
7340 }
7341 else {
7342 rb_hook_list_t *global_hooks = rb_ec_ractor_hooks(ec);
7343 /* Note, not considering iseq local events here since the same
7344 * iseq could be used in multiple bmethods. */
7345 rb_event_flag_t bmethod_events = ractor_events | bmethod_local_events;
7346
7347 if (0) {
7348 ruby_debug_printf("vm_trace>>%4d (%4x) - %s:%d %s\n",
7349 (int)pos,
7350 (int)pc_events,
7351 RSTRING_PTR(rb_iseq_path(iseq)),
7352 (int)rb_iseq_line_no(iseq, pos),
7353 RSTRING_PTR(rb_iseq_label(iseq)));
7354 }
7355 VM_ASSERT(reg_cfp->pc == pc);
7356 VM_ASSERT(pc_events != 0);
7357
7358 /* check traces */
7359 if ((pc_events & RUBY_EVENT_B_CALL) && bmethod_frame && (bmethod_events & RUBY_EVENT_CALL)) {
7360 /* b_call instruction running as a method. Fire call event. */
7361 vm_trace_hook(ec, reg_cfp, pc, RUBY_EVENT_CALL, RUBY_EVENT_CALL, global_hooks, bmethod_local_hooks, Qundef);
7362 }
7364 VM_TRACE_HOOK(RUBY_EVENT_RESCUE, rescue_errinfo(ec, reg_cfp));
7365 VM_TRACE_HOOK(RUBY_EVENT_LINE, Qundef);
7366 VM_TRACE_HOOK(RUBY_EVENT_COVERAGE_LINE, Qundef);
7367 VM_TRACE_HOOK(RUBY_EVENT_COVERAGE_BRANCH, Qundef);
7368 VM_TRACE_HOOK(RUBY_EVENT_END | RUBY_EVENT_RETURN | RUBY_EVENT_B_RETURN, TOPN(0));
7369 if ((pc_events & RUBY_EVENT_B_RETURN) && bmethod_frame && (bmethod_events & RUBY_EVENT_RETURN)) {
7370 /* b_return instruction running as a method. Fire return event. */
7371 /* An earlier event's hook at this pc may have freed bmethod_local_hooks
7372 * (see VM_TRACE_HOOK); reload it from its stable source. */
7373 if (bmethod_hooks_cnt > 0) bmethod_local_hooks = rb_method_def_local_hooks(bmethod_def, r, false);
7374 vm_trace_hook(ec, reg_cfp, pc, RUBY_EVENT_RETURN, RUBY_EVENT_RETURN, global_hooks, bmethod_local_hooks, TOPN(0));
7375 }
7376 }
7377 }
7378}
7379#undef VM_TRACE_HOOK
7380
7381#if VM_CHECK_MODE > 0
7382NORETURN( NOINLINE( COLDFUNC
7383void rb_vm_canary_is_found_dead(enum ruby_vminsn_type i, VALUE c)));
7384
7385void
7386Init_vm_stack_canary(void)
7387{
7388 /* This has to be called _after_ our PRNG is properly set up. */
7389 int n = ruby_fill_random_bytes(&vm_stack_canary, sizeof vm_stack_canary, false);
7390 vm_stack_canary |= 0x01; // valid VALUE (Fixnum)
7391
7392 vm_stack_canary_was_born = true;
7393 VM_ASSERT(n == 0);
7394}
7395
7396void
7397rb_vm_canary_is_found_dead(enum ruby_vminsn_type i, VALUE c)
7398{
7399 /* Because a method has already been called, why not call
7400 * another one. */
7401 const char *insn = rb_insns_name(i);
7402 VALUE inspection = rb_inspect(c);
7403 const char *str = StringValueCStr(inspection);
7404
7405 rb_bug("dead canary found at %s: %s", insn, str);
7406}
7407
7408#else
7409void Init_vm_stack_canary(void) { /* nothing to do */ }
7410#endif
7411
7412
7413/* a part of the following code is generated by this ruby script:
7414
741516.times{|i|
7416 typedef_args = (0...i).map{|j| "VALUE v#{j+1}"}.join(", ")
7417 typedef_args.prepend(", ") if i != 0
7418 call_args = (0...i).map{|j| "argv[#{j}]"}.join(", ")
7419 call_args.prepend(", ") if i != 0
7420 puts %Q{
7421static VALUE
7422builtin_invoker#{i}(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7423{
7424 typedef VALUE (*rb_invoke_funcptr#{i}_t)(rb_execution_context_t *ec, VALUE self#{typedef_args});
7425 return (*(rb_invoke_funcptr#{i}_t)funcptr)(ec, self#{call_args});
7426}}
7427}
7428
7429puts
7430puts "static VALUE (* const cfunc_invokers[])(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr) = {"
743116.times{|i|
7432 puts " builtin_invoker#{i},"
7433}
7434puts "};"
7435*/
7436
7437static VALUE
7438builtin_invoker0(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7439{
7440 typedef VALUE (*rb_invoke_funcptr0_t)(rb_execution_context_t *ec, VALUE self);
7441 return (*(rb_invoke_funcptr0_t)funcptr)(ec, self);
7442}
7443
7444static VALUE
7445builtin_invoker1(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7446{
7447 typedef VALUE (*rb_invoke_funcptr1_t)(rb_execution_context_t *ec, VALUE self, VALUE v1);
7448 return (*(rb_invoke_funcptr1_t)funcptr)(ec, self, argv[0]);
7449}
7450
7451static VALUE
7452builtin_invoker2(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7453{
7454 typedef VALUE (*rb_invoke_funcptr2_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2);
7455 return (*(rb_invoke_funcptr2_t)funcptr)(ec, self, argv[0], argv[1]);
7456}
7457
7458static VALUE
7459builtin_invoker3(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7460{
7461 typedef VALUE (*rb_invoke_funcptr3_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3);
7462 return (*(rb_invoke_funcptr3_t)funcptr)(ec, self, argv[0], argv[1], argv[2]);
7463}
7464
7465static VALUE
7466builtin_invoker4(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7467{
7468 typedef VALUE (*rb_invoke_funcptr4_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4);
7469 return (*(rb_invoke_funcptr4_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3]);
7470}
7471
7472static VALUE
7473builtin_invoker5(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7474{
7475 typedef VALUE (*rb_invoke_funcptr5_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5);
7476 return (*(rb_invoke_funcptr5_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4]);
7477}
7478
7479static VALUE
7480builtin_invoker6(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7481{
7482 typedef VALUE (*rb_invoke_funcptr6_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6);
7483 return (*(rb_invoke_funcptr6_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
7484}
7485
7486static VALUE
7487builtin_invoker7(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7488{
7489 typedef VALUE (*rb_invoke_funcptr7_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7);
7490 return (*(rb_invoke_funcptr7_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
7491}
7492
7493static VALUE
7494builtin_invoker8(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7495{
7496 typedef VALUE (*rb_invoke_funcptr8_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7, VALUE v8);
7497 return (*(rb_invoke_funcptr8_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
7498}
7499
7500static VALUE
7501builtin_invoker9(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7502{
7503 typedef VALUE (*rb_invoke_funcptr9_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7, VALUE v8, VALUE v9);
7504 return (*(rb_invoke_funcptr9_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8]);
7505}
7506
7507static VALUE
7508builtin_invoker10(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7509{
7510 typedef VALUE (*rb_invoke_funcptr10_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7, VALUE v8, VALUE v9, VALUE v10);
7511 return (*(rb_invoke_funcptr10_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]);
7512}
7513
7514static VALUE
7515builtin_invoker11(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7516{
7517 typedef VALUE (*rb_invoke_funcptr11_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7, VALUE v8, VALUE v9, VALUE v10, VALUE v11);
7518 return (*(rb_invoke_funcptr11_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]);
7519}
7520
7521static VALUE
7522builtin_invoker12(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7523{
7524 typedef VALUE (*rb_invoke_funcptr12_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7, VALUE v8, VALUE v9, VALUE v10, VALUE v11, VALUE v12);
7525 return (*(rb_invoke_funcptr12_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11]);
7526}
7527
7528static VALUE
7529builtin_invoker13(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7530{
7531 typedef VALUE (*rb_invoke_funcptr13_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7, VALUE v8, VALUE v9, VALUE v10, VALUE v11, VALUE v12, VALUE v13);
7532 return (*(rb_invoke_funcptr13_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12]);
7533}
7534
7535static VALUE
7536builtin_invoker14(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7537{
7538 typedef VALUE (*rb_invoke_funcptr14_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7, VALUE v8, VALUE v9, VALUE v10, VALUE v11, VALUE v12, VALUE v13, VALUE v14);
7539 return (*(rb_invoke_funcptr14_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13]);
7540}
7541
7542static VALUE
7543builtin_invoker15(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr)
7544{
7545 typedef VALUE (*rb_invoke_funcptr15_t)(rb_execution_context_t *ec, VALUE self, VALUE v1, VALUE v2, VALUE v3, VALUE v4, VALUE v5, VALUE v6, VALUE v7, VALUE v8, VALUE v9, VALUE v10, VALUE v11, VALUE v12, VALUE v13, VALUE v14, VALUE v15);
7546 return (*(rb_invoke_funcptr15_t)funcptr)(ec, self, argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10], argv[11], argv[12], argv[13], argv[14]);
7547}
7548
7549typedef VALUE (*builtin_invoker)(rb_execution_context_t *ec, VALUE self, const VALUE *argv, rb_insn_func_t funcptr);
7550
7551static builtin_invoker
7552lookup_builtin_invoker(int argc)
7553{
7554 static const builtin_invoker invokers[] = {
7555 builtin_invoker0,
7556 builtin_invoker1,
7557 builtin_invoker2,
7558 builtin_invoker3,
7559 builtin_invoker4,
7560 builtin_invoker5,
7561 builtin_invoker6,
7562 builtin_invoker7,
7563 builtin_invoker8,
7564 builtin_invoker9,
7565 builtin_invoker10,
7566 builtin_invoker11,
7567 builtin_invoker12,
7568 builtin_invoker13,
7569 builtin_invoker14,
7570 builtin_invoker15,
7571 };
7572
7573 return invokers[argc];
7574}
7575
7576static inline VALUE
7577invoke_bf(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, const struct rb_builtin_function* bf, const VALUE *argv)
7578{
7579 const bool canary_p = ISEQ_BODY(reg_cfp->iseq)->builtin_attrs & BUILTIN_ATTR_LEAF; // Verify an assumption of `Primitive.attr! :leaf`
7580 SETUP_CANARY(canary_p);
7581 rb_insn_func_t func_ptr = (rb_insn_func_t)(uintptr_t)bf->func_ptr;
7582 VALUE ret = (*lookup_builtin_invoker(bf->argc))(ec, reg_cfp->self, argv, func_ptr);
7583 CHECK_CANARY(canary_p, BIN(invokebuiltin));
7584 return ret;
7585}
7586
7587static VALUE
7588vm_invoke_builtin(rb_execution_context_t *ec, rb_control_frame_t *cfp, const struct rb_builtin_function* bf, const VALUE *argv)
7589{
7590 return invoke_bf(ec, cfp, bf, argv);
7591}
7592
7593static VALUE
7594vm_invoke_builtin_delegate(rb_execution_context_t *ec, rb_control_frame_t *cfp, const struct rb_builtin_function *bf, unsigned int start_index)
7595{
7596 if (0) { // debug print
7597 fputs("vm_invoke_builtin_delegate: passing -> ", stderr);
7598 for (int i=0; i<bf->argc; i++) {
7599 ruby_debug_printf(":%s ", rb_id2name(ISEQ_BODY(cfp->iseq)->local_table[i+start_index]));
7600 }
7601 ruby_debug_printf("\n" "%s %s(%d):%p\n", RUBY_FUNCTION_NAME_STRING, bf->name, bf->argc,
7602 (void *)(uintptr_t)bf->func_ptr);
7603 }
7604
7605 if (bf->argc == 0) {
7606 return invoke_bf(ec, cfp, bf, NULL);
7607 }
7608 else {
7609 const VALUE *argv = cfp->ep - ISEQ_BODY(cfp->iseq)->local_table_size - VM_ENV_DATA_SIZE + 1 + start_index;
7610 return invoke_bf(ec, cfp, bf, argv);
7611 }
7612}
7613
7614// for __builtin_inline!()
7615
7616VALUE
7617rb_vm_lvar_exposed(rb_execution_context_t *ec, int index)
7618{
7619 const rb_control_frame_t *cfp = ec->cfp;
7620 return cfp->ep[index];
7621}
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
#define RUBY_EVENT_END
Encountered an end of a class clause.
Definition event.h:40
#define RUBY_EVENT_C_CALL
A method, written in C, is called.
Definition event.h:43
#define RUBY_EVENT_B_RETURN
Encountered a next statement.
Definition event.h:56
#define RUBY_EVENT_CLASS
Encountered a new class.
Definition event.h:39
#define RUBY_EVENT_LINE
Encountered a new line.
Definition event.h:38
#define RUBY_EVENT_RETURN
Encountered a return statement.
Definition event.h:42
#define RUBY_EVENT_C_RETURN
Return from a method, written in C.
Definition event.h:44
#define RUBY_EVENT_B_CALL
Encountered an yield statement.
Definition event.h:55
uint32_t rb_event_flag_t
Represents event(s).
Definition event.h:108
#define RUBY_EVENT_CALL
A method, written in Ruby, is called.
Definition event.h:41
#define RUBY_EVENT_RESCUE
Encountered a rescue statement.
Definition event.h:61
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
Definition class.c:2825
VALUE rb_module_new(void)
Creates a new, anonymous module.
Definition class.c:1582
VALUE rb_class_inherited(VALUE super, VALUE klass)
Calls Class::inherited.
Definition class.c:1479
VALUE rb_define_class_id(ID id, VALUE super)
This is a very badly designed API that creates an anonymous class.
Definition class.c:1458
#define TYPE(_)
Old name of rb_type.
Definition value_type.h:108
#define RFLOAT_VALUE
Old name of rb_float_value.
Definition double.h:28
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
#define T_NIL
Old name of RUBY_T_NIL.
Definition value_type.h:72
#define T_FLOAT
Old name of RUBY_T_FLOAT.
Definition value_type.h:64
#define T_IMEMO
Old name of RUBY_T_IMEMO.
Definition value_type.h:67
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
Definition value_type.h:57
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
Definition value_type.h:79
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
Definition value_type.h:63
#define SYM2ID
Old name of RB_SYM2ID.
Definition symbol.h:45
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:205
#define rb_ary_new4
Old name of rb_ary_new_from_values.
Definition array.h:659
#define FIXABLE
Old name of RB_FIXABLE.
Definition fixnum.h:25
#define LONG2FIX
Old name of RB_INT2FIX.
Definition long.h:49
#define FIX2INT
Old name of RB_FIX2INT.
Definition int.h:41
#define T_MODULE
Old name of RUBY_T_MODULE.
Definition value_type.h:70
#define STATIC_SYM_P
Old name of RB_STATIC_SYM_P.
#define ASSUME
Old name of RBIMPL_ASSUME.
Definition assume.h:27
#define FIX2ULONG
Old name of RB_FIX2ULONG.
Definition long.h:47
#define T_TRUE
Old name of RUBY_T_TRUE.
Definition value_type.h:81
#define T_ICLASS
Old name of RUBY_T_ICLASS.
Definition value_type.h:66
#define T_HASH
Old name of RUBY_T_HASH.
Definition value_type.h:65
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
Definition fl_type.h:131
#define rb_ary_new3
Old name of rb_ary_new_from_args.
Definition array.h:658
#define LONG2NUM
Old name of RB_LONG2NUM.
Definition long.h:50
#define rb_exc_new3
Old name of rb_exc_new_str.
Definition error.h:38
#define T_FALSE
Old name of RUBY_T_FALSE.
Definition value_type.h:61
#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.
Definition long.h:46
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
#define T_OBJECT
Old name of RUBY_T_OBJECT.
Definition value_type.h:75
#define NIL_P
Old name of RB_NIL_P.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
Definition value_type.h:80
#define DBL2NUM
Old name of rb_float_new.
Definition double.h:29
#define T_CLASS
Old name of RUBY_T_CLASS.
Definition value_type.h:58
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
Definition value_type.h:85
#define FL_TEST
Old name of RB_FL_TEST.
Definition fl_type.h:130
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define FL_USHIFT
Old name of RUBY_FL_USHIFT.
Definition fl_type.h:68
#define FL_SET_RAW
Old name of RB_FL_SET_RAW.
Definition fl_type.h:129
#define SYMBOL_P
Old name of RB_SYMBOL_P.
Definition value_type.h:88
void rb_notimplement(void)
Definition error.c:3842
void rb_exc_raise(VALUE mesg)
Raises an exception in the current thread.
Definition eval.c:664
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
Definition error.h:475
VALUE rb_eTypeError
TypeError exception.
Definition error.c:1431
VALUE rb_eFatal
fatal exception.
Definition error.c:1427
VALUE rb_eNoMethodError
NoMethodError exception.
Definition error.c:1439
void rb_exc_fatal(VALUE mesg)
Raises a fatal error in the current thread.
Definition eval.c:677
VALUE rb_eRuntimeError
RuntimeError exception.
Definition error.c:1429
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:466
void rb_error_frozen_object(VALUE frozen_obj)
Identical to rb_error_frozen(), except it takes arbitrary Ruby object instead of C's string.
Definition error.c:4163
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.
Definition error.c:1482
VALUE rb_ensure(VALUE(*b_proc)(VALUE), VALUE data1, VALUE(*e_proc)(VALUE), VALUE data2)
An equivalent to ensure clause.
Definition eval.c:1178
@ RB_WARN_CATEGORY_STRICT_UNUSED_BLOCK
Warning is for checking unused block strictly.
Definition error.h:57
VALUE rb_cClass
Class class.
Definition object.c:63
VALUE rb_cArray
Array class.
VALUE rb_obj_alloc(VALUE klass)
Allocates an instance of the given class.
Definition object.c:2208
VALUE rb_cRegexp
Regexp class.
Definition re.c:2672
VALUE rb_obj_frozen_p(VALUE obj)
Just calls RB_OBJ_FROZEN() inside.
Definition object.c:1354
VALUE rb_cHash
Hash class.
Definition hash.c:109
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
Definition object.c:264
VALUE rb_inspect(VALUE obj)
Generates a human-readable textual representation of the given object.
Definition object.c:686
VALUE rb_cBasicObject
BasicObject class.
Definition object.c:59
VALUE rb_cModule
Module class.
Definition object.c:62
VALUE rb_class_real(VALUE klass)
Finds a "real" class.
Definition object.c:255
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.
Definition object.c:923
VALUE rb_cFloat
Float class.
Definition numeric.c:199
VALUE rb_cProc
Proc class.
Definition proc.c:45
VALUE rb_cString
String class.
Definition string.c:84
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
Definition gc.h:615
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
Definition gc.h:603
VALUE rb_ary_concat(VALUE lhs, VALUE rhs)
Destructively appends the contents of latter into the end of former.
VALUE rb_ary_shift(VALUE ary)
Destructively deletes an element from the beginning of the passed array and returns what was deleted.
VALUE rb_ary_resurrect(VALUE ary)
I guess there is no use case of this function in extension libraries, but this is a routine identical...
VALUE rb_ary_dup(VALUE ary)
Duplicates an array.
VALUE rb_ary_includes(VALUE ary, VALUE elem)
Queries if the passed array has the passed entry.
VALUE rb_ary_plus(VALUE lhs, VALUE rhs)
Creates a new array, concatenating the former to the latter.
VALUE rb_ary_cat(VALUE ary, const VALUE *train, long len)
Destructively appends multiple elements at the end of the array.
VALUE rb_check_array_type(VALUE obj)
Try converting an object to its array representation using its to_ary method, if any.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_pop(VALUE ary)
Destructively deletes an element from the end of the passed array and returns what was deleted.
VALUE rb_ary_hidden_new(long capa)
Allocates a hidden (no class) empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
VALUE rb_ary_entry(VALUE ary, long off)
Queries an element of an array.
void rb_ary_store(VALUE ary, long key, VALUE val)
Destructively stores the passed value to the passed array's passed index.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
Definition error.h:35
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,...
Definition proc.c:1180
VALUE rb_reg_last_match(VALUE md)
This just returns the argument, stringified.
Definition re.c:1962
VALUE rb_reg_match(VALUE re, VALUE str)
This is the match operator.
Definition re.c:3739
VALUE rb_reg_nth_match(int n, VALUE md)
Queries the nth captured substring.
Definition re.c:1937
VALUE rb_reg_match_post(VALUE md)
The portion of the original string after the given match.
Definition re.c:2019
VALUE rb_reg_nth_defined(int n, VALUE md)
Identical to rb_reg_nth_match(), except it just returns Boolean.
Definition re.c:1920
VALUE rb_reg_match_pre(VALUE md)
The portion of the original string before the given match.
Definition re.c:1986
VALUE rb_reg_match_last(VALUE md)
The portion of the original string that captured at the very last.
Definition re.c:2052
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
Definition string.c:3833
VALUE rb_str_succ(VALUE orig)
Searches for the "successor" of a string.
Definition string.c:5389
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.
Definition string.c:3797
VALUE rb_str_concat(VALUE dst, VALUE src)
Identical to rb_str_append(), except it also accepts an integer as a codepoint.
Definition string.c:4073
#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.
Definition string.h:1657
VALUE rb_str_length(VALUE)
Identical to rb_str_strlen(), except it returns the value in rb_cInteger.
Definition string.c:2466
VALUE rb_str_intern(VALUE str)
Identical to rb_to_symbol(), except it assumes the receiver being an instance of RString.
Definition symbol.c:937
void rb_thread_schedule(void)
Tries to switch to another thread.
Definition thread.c:1514
VALUE rb_const_get(VALUE space, ID name)
Identical to rb_const_defined(), except it returns the actual defined value.
Definition variable.c:3505
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.
Definition variable.c:2030
void rb_cvar_set(VALUE klass, ID name, VALUE val)
Assigns a value to a class variable.
Definition variable.c:4305
VALUE rb_cvar_find(VALUE klass, ID name, VALUE *front)
Identical to rb_cvar_get(), except it takes additional "front" pointer.
Definition variable.c:4368
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.
Definition variable.c:1505
void rb_const_set(VALUE space, ID name, VALUE val)
Names a constant.
Definition variable.c:3983
VALUE rb_autoload_load(VALUE space, ID name)
Kicks the autoload procedure as if it was "touched".
Definition variable.c:3335
VALUE rb_mod_name(VALUE mod)
Queries the name of a module.
Definition variable.c:136
VALUE rb_const_get_at(VALUE space, ID name)
Identical to rb_const_defined_at(), except it returns the actual defined value.
Definition variable.c:3511
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.
Definition variable.c:423
VALUE rb_ivar_defined(VALUE obj, ID name)
Queries if the instance variable is defined at the object.
Definition variable.c:2109
int rb_const_defined_at(VALUE space, ID name)
Identical to rb_const_defined(), except it doesn't look for parent classes.
Definition variable.c:3843
VALUE rb_cvar_defined(VALUE klass, ID name)
Queries if the given class has the given class variable.
Definition variable.c:4390
VALUE rb_class_path(VALUE mod)
Identical to rb_mod_name(), except it returns #<Class: ...> style inspection for anonymous modules.
Definition variable.c:380
int rb_const_defined(VALUE space, ID name)
Queries if the constant is defined at the namespace.
Definition variable.c:3837
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.
Definition vm_eval.c:688
rb_alloc_func_t rb_get_alloc_func(VALUE klass)
Queries the allocator function of a class.
Definition vm_method.c:1725
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
int rb_method_boundp(VALUE klass, ID id, int ex)
Queries if the klass has this method.
Definition vm_method.c:2316
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
Definition symbol.c:1134
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
Definition symbol.c:994
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
Definition io.h:2
int off
Offset inside of ptr.
Definition io.h:5
int len
Length of the buffer.
Definition io.h:8
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
Definition ractor.h:235
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
Definition memory.h:372
#define ALLOCA_N(type, n)
Definition memory.h:292
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
#define MEMMOVE(p1, p2, type, n)
Handy macro to call memmove.
Definition memory.h:384
VALUE type(ANYARGS)
ANYARGS-ed function type.
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
#define RARRAY_AREF(a, i)
Definition rarray.h:403
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
Definition rarray.h:52
#define RBASIC(obj)
Convenient casting macro.
Definition rbasic.h:40
#define RCLASS_SUPER
Just another name of rb_class_get_superclass.
Definition rclass.h:44
#define RHASH_SIZE(h)
Queries the size of the hash.
Definition rhash.h:69
#define RHASH_EMPTY_P(h)
Checks if the hash is empty.
Definition rhash.h:79
#define StringValueCStr(v)
Identical to StringValuePtr, except it additionally checks for the contents for viability as a C stri...
Definition rstring.h:89
#define RB_PASS_KEYWORDS
Pass keywords, final argument should be a hash of keywords.
Definition scan_args.h:72
#define RB_NO_KEYWORDS
Do not pass keywords.
Definition scan_args.h:69
#define RTEST
This is an old name of RB_TEST.
#define ANYARGS
Functions declared using this macro take arbitrary arguments, including void.
Definition stdarg.h:64
Ruby's array.
Definition rarray.h:128
Definition hash.h:53
Definition iseq.h:281
Definition vm_core.h:261
const ID * segments
A null-terminated list of ids, used to represent a constant's path idNULL is used to represent the ::...
Definition vm_core.h:285
Definition method.h:63
Definition class.h:37
IFUNC (Internal FUNCtion).
Definition imemo.h:86
SVAR (Special VARiable).
Definition imemo.h:50
const VALUE cref_or_me
class reference or rb_method_entry_t
Definition imemo.h:52
THROW_DATA.
Definition imemo.h:59
Definition vm_core.h:297
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
Definition value.h:63
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
Definition value.h:69
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40