Ruby 3.5.0dev (2025-10-06 revision 704677257ecb01c7ee10aa0dfc55ca1d4fc4636d)
vm_method.c (704677257ecb01c7ee10aa0dfc55ca1d4fc4636d)
1/*
2 * This file is included by vm.c
3 */
4
5#include "id_table.h"
6#include "yjit.h"
7
8#define METHOD_DEBUG 0
9
10static int vm_redefinition_check_flag(VALUE klass);
11static void rb_vm_check_redefinition_opt_method(const rb_method_entry_t *me, VALUE klass);
12static inline rb_method_entry_t *lookup_method_table(VALUE klass, ID id);
13
14#define object_id idObject_id
15#define added idMethod_added
16#define singleton_added idSingleton_method_added
17#define removed idMethod_removed
18#define singleton_removed idSingleton_method_removed
19#define undefined idMethod_undefined
20#define singleton_undefined idSingleton_method_undefined
21
22#define ruby_running (GET_VM()->running)
23/* int ruby_running = 0; */
24
25static enum rb_id_table_iterator_result
26mark_cc_entry_i(VALUE ccs_ptr, void *data)
27{
28 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_ptr;
29
30 VM_ASSERT(vm_ccs_p(ccs));
31
32 if (METHOD_ENTRY_INVALIDATED(ccs->cme)) {
33 /* Before detaching the CCs from this class, we need to invalidate the cc
34 * since we will no longer be marking the cme on their behalf.
35 */
36 for (int i = 0; i < ccs->len; i++) {
37 const struct rb_callcache *cc = ccs->entries[i].cc;
38 if (cc->klass == Qundef) continue; // already invalidated
39 VM_ASSERT(cc->klass == Qundef || vm_cc_check_cme(cc, ccs->cme));
40 VM_ASSERT(!vm_cc_super_p(cc) && !vm_cc_refinement_p(cc));
41 vm_cc_invalidate(cc);
42 }
43 ruby_xfree(ccs);
44 return ID_TABLE_DELETE;
45 }
46 else {
47 rb_gc_mark_movable((VALUE)ccs->cme);
48
49 for (int i = 0; i < ccs->len; i++) {
50 const struct rb_callcache *cc = ccs->entries[i].cc;
51 VM_ASSERT(cc->klass == Qundef || vm_cc_check_cme(cc, ccs->cme));
52
53 rb_gc_mark_movable((VALUE)cc);
54 }
55 return ID_TABLE_CONTINUE;
56 }
57}
58
59static void
60vm_cc_table_mark(void *data)
61{
62 struct rb_id_table *tbl = (struct rb_id_table *)data;
63 if (tbl) {
64 rb_id_table_foreach_values(tbl, mark_cc_entry_i, NULL);
65 }
66}
67
68static enum rb_id_table_iterator_result
69cc_table_free_i(VALUE ccs_ptr, void *data)
70{
71 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_ptr;
72 VM_ASSERT(vm_ccs_p(ccs));
73
74 ruby_xfree(ccs);
75
76 return ID_TABLE_CONTINUE;
77}
78
79static void
80vm_cc_table_free(void *data)
81{
82 struct rb_id_table *tbl = (struct rb_id_table *)data;
83
84 rb_id_table_foreach_values(tbl, cc_table_free_i, NULL);
85 rb_managed_id_table_type.function.dfree(data);
86}
87
88static enum rb_id_table_iterator_result
89cc_table_memsize_i(VALUE ccs_ptr, void *data_ptr)
90{
91 size_t *total_size = data_ptr;
92 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_ptr;
93 *total_size += sizeof(*ccs);
94 *total_size += sizeof(ccs->entries[0]) * ccs->capa;
95 return ID_TABLE_CONTINUE;
96}
97
98static size_t
99vm_cc_table_memsize(const void *data)
100{
101 size_t memsize = rb_managed_id_table_type.function.dsize(data);
102 struct rb_id_table *tbl = (struct rb_id_table *)data;
103 rb_id_table_foreach_values(tbl, cc_table_memsize_i, &memsize);
104 return memsize;
105}
106
107static enum rb_id_table_iterator_result
108compact_cc_entry_i(VALUE ccs_ptr, void *data)
109{
110 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_ptr;
111
112 ccs->cme = (const struct rb_callable_method_entry_struct *)rb_gc_location((VALUE)ccs->cme);
113 VM_ASSERT(vm_ccs_p(ccs));
114
115 for (int i=0; i<ccs->len; i++) {
116 ccs->entries[i].cc = (const struct rb_callcache *)rb_gc_location((VALUE)ccs->entries[i].cc);
117 }
118
119 return ID_TABLE_CONTINUE;
120}
121
122static void
123vm_cc_table_compact(void *data)
124{
125 struct rb_id_table *tbl = (struct rb_id_table *)data;
126 rb_id_table_foreach_values(tbl, compact_cc_entry_i, NULL);
127}
128
129static const rb_data_type_t cc_table_type = {
130 .wrap_struct_name = "VM/cc_table",
131 .function = {
132 .dmark = vm_cc_table_mark,
133 .dfree = vm_cc_table_free,
134 .dsize = vm_cc_table_memsize,
135 .dcompact = vm_cc_table_compact,
136 },
137 .parent = &rb_managed_id_table_type,
138 .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE,
139};
140
141VALUE
142rb_vm_cc_table_create(size_t capa)
143{
144 return rb_managed_id_table_create(&cc_table_type, capa);
145}
146
147static enum rb_id_table_iterator_result
148vm_cc_table_dup_i(ID key, VALUE old_ccs_ptr, void *data)
149{
150 VALUE new_table = (VALUE)data;
151 struct rb_class_cc_entries *old_ccs = (struct rb_class_cc_entries *)old_ccs_ptr;
152 size_t memsize = vm_ccs_alloc_size(old_ccs->capa);
153 struct rb_class_cc_entries *new_ccs = ruby_xcalloc(1, memsize);
154 rb_managed_id_table_insert(new_table, key, (VALUE)new_ccs);
155
156 memcpy(new_ccs, old_ccs, memsize);
157
158#if VM_CHECK_MODE > 0
159 new_ccs->debug_sig = ~(VALUE)new_ccs;
160#endif
161
162 RB_OBJ_WRITTEN(new_table, Qundef, (VALUE)new_ccs->cme);
163 for (int index = 0; index < new_ccs->len; index++) {
164 RB_OBJ_WRITTEN(new_table, Qundef, new_ccs->entries[index].cc);
165 }
166 return ID_TABLE_CONTINUE;
167}
168
169VALUE
170rb_vm_cc_table_dup(VALUE old_table)
171{
172 VALUE new_table = rb_vm_cc_table_create(rb_managed_id_table_size(old_table));
173 rb_managed_id_table_foreach(old_table, vm_cc_table_dup_i, (void *)new_table);
174 return new_table;
175}
176
177static void
178vm_ccs_invalidate(struct rb_class_cc_entries *ccs)
179{
180 for (int i=0; i<ccs->len; i++) {
181 const struct rb_callcache *cc = ccs->entries[i].cc;
182 VM_ASSERT(!vm_cc_super_p(cc) && !vm_cc_refinement_p(cc));
183 vm_cc_invalidate(cc);
184 }
185}
186
187void
188rb_vm_ccs_invalidate_and_free(struct rb_class_cc_entries *ccs)
189{
190 RB_DEBUG_COUNTER_INC(ccs_free);
191 vm_ccs_invalidate(ccs);
192 ruby_xfree(ccs);
193}
194
195void
196rb_vm_cc_table_delete(VALUE table, ID mid)
197{
198 VALUE ccs_obj;
199 if (rb_managed_id_table_lookup(table, mid, &ccs_obj)) {
200 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_obj;
201 rb_managed_id_table_delete(table, mid);
202 rb_vm_ccs_invalidate_and_free(ccs);
203 }
204}
205
206static enum rb_id_table_iterator_result
207vm_ccs_dump_i(ID mid, VALUE val, void *data)
208{
209 const struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)val;
210 fprintf(stderr, " | %s (len:%d) ", rb_id2name(mid), ccs->len);
211 rp(ccs->cme);
212
213 for (int i=0; i<ccs->len; i++) {
214 rp_m( " | \t", ccs->entries[i].cc);
215 }
216
217 return ID_TABLE_CONTINUE;
218}
219
220static void
221vm_ccs_dump(VALUE klass, ID target_mid)
222{
223 VALUE cc_tbl = RCLASS_WRITABLE_CC_TBL(klass);
224 if (cc_tbl) {
225 VALUE ccs;
226 if (target_mid) {
227 if (rb_managed_id_table_lookup(cc_tbl, target_mid, &ccs)) {
228 fprintf(stderr, " [CCTB] %p\n", (void *)cc_tbl);
229 vm_ccs_dump_i(target_mid, ccs, NULL);
230 }
231 }
232 else {
233 fprintf(stderr, " [CCTB] %p\n", (void *)cc_tbl);
234 rb_managed_id_table_foreach(cc_tbl, vm_ccs_dump_i, (void *)target_mid);
235 }
236 }
237}
238
239static enum rb_id_table_iterator_result
240vm_cme_dump_i(ID mid, VALUE val, void *data)
241{
242 ID target_mid = (ID)data;
243 if (target_mid == 0 || mid == target_mid) {
244 rp_m(" > ", val);
245 }
246 return ID_TABLE_CONTINUE;
247}
248
249static VALUE
250vm_mtbl_dump(VALUE klass, ID target_mid)
251{
252 fprintf(stderr, "# vm_mtbl\n");
253 while (klass) {
254 rp_m(" -> ", klass);
255 VALUE me;
256
257 if (RCLASS_M_TBL(klass)) {
258 if (target_mid != 0) {
259 if (rb_id_table_lookup(RCLASS_M_TBL(klass), target_mid, &me)) {
260 rp_m(" [MTBL] ", me);
261 }
262 }
263 else {
264 fprintf(stderr, " ## RCLASS_M_TBL (%p)\n", (void *)RCLASS_M_TBL(klass));
265 rb_id_table_foreach(RCLASS_M_TBL(klass), vm_cme_dump_i, NULL);
266 }
267 }
268 else {
269 fprintf(stderr, " MTBL: NULL\n");
270 }
271 if (RCLASS_WRITABLE_CALLABLE_M_TBL(klass)) {
272 if (target_mid != 0) {
273 if (rb_id_table_lookup(RCLASS_WRITABLE_CALLABLE_M_TBL(klass), target_mid, &me)) {
274 rp_m(" [CM**] ", me);
275 }
276 }
277 else {
278 fprintf(stderr, " ## RCLASS_CALLABLE_M_TBL\n");
279 rb_id_table_foreach(RCLASS_WRITABLE_CALLABLE_M_TBL(klass), vm_cme_dump_i, NULL);
280 }
281 }
282 if (RCLASS_WRITABLE_CC_TBL(klass)) {
283 vm_ccs_dump(klass, target_mid);
284 }
285 klass = RCLASS_SUPER(klass);
286 }
287 return Qnil;
288}
289
290void
291rb_vm_mtbl_dump(const char *msg, VALUE klass, ID target_mid)
292{
293 fprintf(stderr, "[%s] ", msg);
294 vm_mtbl_dump(klass, target_mid);
295}
296
297static inline void
298vm_cme_invalidate(rb_callable_method_entry_t *cme)
299{
300 VM_ASSERT(IMEMO_TYPE_P(cme, imemo_ment), "cme: %d", imemo_type((VALUE)cme));
301 VM_ASSERT(callable_method_entry_p(cme));
302 METHOD_ENTRY_INVALIDATED_SET(cme);
303 RB_DEBUG_COUNTER_INC(cc_cme_invalidate);
304
305 rb_yjit_cme_invalidate(cme);
306 rb_zjit_cme_invalidate(cme);
307}
308
309static int
310rb_clear_constant_cache_for_id_i(st_data_t ic, st_data_t arg)
311{
312 ((IC) ic)->entry = NULL;
313 return ST_CONTINUE;
314}
315
316// Here for backward compat.
317void rb_clear_constant_cache(void) {}
318
319void
321{
322 VALUE lookup_result;
323 rb_vm_t *vm = GET_VM();
324
325 if (rb_id_table_lookup(vm->constant_cache, id, &lookup_result)) {
326 set_table *ics = (set_table *)lookup_result;
327 set_table_foreach(ics, rb_clear_constant_cache_for_id_i, (st_data_t) NULL);
328 ruby_vm_constant_cache_invalidations += ics->num_entries;
329 }
330
331 rb_yjit_constant_state_changed(id);
332 rb_zjit_constant_state_changed(id);
333}
334
335static void
336invalidate_negative_cache(ID mid)
337{
338 VALUE cme;
339 rb_vm_t *vm = GET_VM();
340
341 if (rb_id_table_lookup(vm->negative_cme_table, mid, &cme)) {
342 rb_id_table_delete(vm->negative_cme_table, mid);
343 vm_cme_invalidate((rb_callable_method_entry_t *)cme);
344 RB_DEBUG_COUNTER_INC(cc_invalidate_negative);
345 }
346}
347
348const rb_method_entry_t * rb_method_entry_clone(const rb_method_entry_t *src_me);
349static const rb_callable_method_entry_t *complemented_callable_method_entry(VALUE klass, ID id);
350static const rb_callable_method_entry_t *lookup_overloaded_cme(const rb_callable_method_entry_t *cme);
351
352static void
353invalidate_method_cache_in_cc_table(VALUE tbl, ID mid)
354{
355 VALUE ccs_data;
356 if (tbl && rb_managed_id_table_lookup(tbl, mid, &ccs_data)) {
357 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_data;
358 rb_yjit_cme_invalidate((rb_callable_method_entry_t *)ccs->cme);
359 rb_zjit_cme_invalidate((rb_callable_method_entry_t *)ccs->cme);
360 if (NIL_P(ccs->cme->owner)) invalidate_negative_cache(mid);
361 rb_vm_ccs_invalidate_and_free(ccs);
362 rb_managed_id_table_delete(tbl, mid);
363 RB_DEBUG_COUNTER_INC(cc_invalidate_leaf_ccs);
364 }
365}
366
367static void
368invalidate_callable_method_entry_in_callable_m_table(struct rb_id_table *tbl, ID mid)
369{
370 VALUE cme;
371 if (tbl && rb_id_table_lookup(tbl, mid, &cme)) {
372 rb_yjit_cme_invalidate((rb_callable_method_entry_t *)cme);
373 rb_zjit_cme_invalidate((rb_callable_method_entry_t *)cme);
374 rb_id_table_delete(tbl, mid);
375 RB_DEBUG_COUNTER_INC(cc_invalidate_leaf_callable);
376 }
377}
378
380 VALUE klass;
381 ID mid;
382 const rb_method_entry_t *cme;
383 const rb_method_entry_t *newer;
384};
385
386static void
387invalidate_callable_method_entry_in_every_m_table_i(rb_classext_t *ext, bool is_prime, VALUE namespace, void *data)
388{
389 st_data_t me;
391 struct rb_id_table *tbl = RCLASSEXT_M_TBL(ext);
392
393 if (rb_id_table_lookup(tbl, arg->mid, &me) && arg->cme == (const rb_method_entry_t *)me) {
394 rb_method_table_insert(arg->klass, tbl, arg->mid, arg->newer);
395 }
396}
397
398static void
399invalidate_callable_method_entry_in_every_m_table(VALUE klass, ID mid, const rb_callable_method_entry_t *cme)
400{
401 // The argument cme must be invalidated later in the caller side
402 const rb_method_entry_t *newer = rb_method_entry_clone((const rb_method_entry_t *)cme);
404 .klass = klass,
405 .mid = mid,
406 .cme = (const rb_method_entry_t *) cme,
407 .newer = newer,
408 };
409 rb_class_classext_foreach(klass, invalidate_callable_method_entry_in_every_m_table_i, (void *)&arg);
410}
411
412static void
413invalidate_complemented_method_entry_in_callable_m_table(struct rb_id_table *tbl, ID mid)
414{
415 VALUE cme;
416 if (tbl && rb_id_table_lookup(tbl, mid, &cme)) {
417 rb_yjit_cme_invalidate((rb_callable_method_entry_t *)cme);
418 rb_zjit_cme_invalidate((rb_callable_method_entry_t *)cme);
419 rb_id_table_delete(tbl, mid);
420 RB_DEBUG_COUNTER_INC(cc_invalidate_tree_callable);
421 }
422}
423
424static void
425clear_method_cache_by_id_in_class(VALUE klass, ID mid)
426{
427 VM_ASSERT_TYPE2(klass, T_CLASS, T_ICLASS);
428 if (rb_objspace_garbage_object_p(klass)) return;
429
430 RB_VM_LOCKING() {
431 rb_vm_barrier();
432
433 if (LIKELY(RCLASS_SUBCLASSES_FIRST(klass) == NULL)) {
434 // no subclasses
435 // check only current class
436
437 // invalidate CCs
438 VALUE cc_tbl = RCLASS_WRITABLE_CC_TBL(klass);
439 invalidate_method_cache_in_cc_table(cc_tbl, mid);
440 if (RCLASS_CC_TBL_NOT_PRIME_P(klass, cc_tbl)) {
441 invalidate_method_cache_in_cc_table(RCLASS_PRIME_CC_TBL(klass), mid);
442 }
443
444 // remove from callable_m_tbl, if exists
445 struct rb_id_table *cm_tbl = RCLASS_WRITABLE_CALLABLE_M_TBL(klass);
446 invalidate_callable_method_entry_in_callable_m_table(cm_tbl, mid);
447 if (RCLASS_CALLABLE_M_TBL_NOT_PRIME_P(klass, cm_tbl)) {
448 invalidate_callable_method_entry_in_callable_m_table(RCLASS_PRIME_CALLABLE_M_TBL(klass), mid);
449 }
450
451 RB_DEBUG_COUNTER_INC(cc_invalidate_leaf);
452 }
453 else {
454 const rb_callable_method_entry_t *cme = complemented_callable_method_entry(klass, mid);
455
456 if (cme) {
457 // invalidate cme if found to invalidate the inline method cache.
458 if (METHOD_ENTRY_CACHED(cme)) {
459 if (METHOD_ENTRY_COMPLEMENTED(cme)) {
460 // do nothing
461 }
462 else {
463 // invalidate cc by invalidating cc->cme
464 VALUE owner = cme->owner;
465 VM_ASSERT_TYPE(owner, T_CLASS);
466 VALUE klass_housing_cme;
467 if (cme->def->type == VM_METHOD_TYPE_REFINED && !cme->def->body.refined.orig_me) {
468 klass_housing_cme = owner;
469 }
470 else {
471 klass_housing_cme = RCLASS_ORIGIN(owner);
472 }
473
474 // replace the cme that will be invalid in the all classexts
475 invalidate_callable_method_entry_in_every_m_table(klass_housing_cme, mid, cme);
476 }
477
478 vm_cme_invalidate((rb_callable_method_entry_t *)cme);
479 RB_DEBUG_COUNTER_INC(cc_invalidate_tree_cme);
480
481 // In case of refinement ME, also invalidate the wrapped ME that
482 // could be cached at some callsite and is unreachable from any
483 // RCLASS_WRITABLE_CC_TBL.
484 if (cme->def->type == VM_METHOD_TYPE_REFINED && cme->def->body.refined.orig_me) {
485 vm_cme_invalidate((rb_callable_method_entry_t *)cme->def->body.refined.orig_me);
486 }
487
488 if (cme->def->iseq_overload) {
489 rb_callable_method_entry_t *monly_cme = (rb_callable_method_entry_t *)lookup_overloaded_cme(cme);
490 if (monly_cme) {
491 vm_cme_invalidate(monly_cme);
492 }
493 }
494 }
495
496 // invalidate complement tbl
497 if (METHOD_ENTRY_COMPLEMENTED(cme)) {
498 VALUE defined_class = cme->defined_class;
499 struct rb_id_table *cm_tbl = RCLASS_WRITABLE_CALLABLE_M_TBL(defined_class);
500 invalidate_complemented_method_entry_in_callable_m_table(cm_tbl, mid);
501 if (RCLASS_CALLABLE_M_TBL_NOT_PRIME_P(defined_class, cm_tbl)) {
502 struct rb_id_table *prime_cm_table = RCLASS_PRIME_CALLABLE_M_TBL(defined_class);
503 invalidate_complemented_method_entry_in_callable_m_table(prime_cm_table, mid);
504 }
505 }
506
507 RB_DEBUG_COUNTER_INC(cc_invalidate_tree);
508 }
509 else {
510 invalidate_negative_cache(mid);
511 }
512 }
513
514 rb_gccct_clear_table(Qnil);
515 }
516}
517
518static void
519clear_iclass_method_cache_by_id(VALUE iclass, VALUE d)
520{
521 VM_ASSERT_TYPE(iclass, T_ICLASS);
522 ID mid = (ID)d;
523 clear_method_cache_by_id_in_class(iclass, mid);
524}
525
526static void
527clear_iclass_method_cache_by_id_for_refinements(VALUE klass, VALUE d)
528{
529 if (RB_TYPE_P(klass, T_ICLASS)) {
530 ID mid = (ID)d;
531 clear_method_cache_by_id_in_class(klass, mid);
532 }
533}
534
535void
536rb_clear_method_cache(VALUE klass_or_module, ID mid)
537{
538 if (RB_TYPE_P(klass_or_module, T_MODULE)) {
539 VALUE module = klass_or_module; // alias
540
541 if (FL_TEST(module, RMODULE_IS_REFINEMENT)) {
542 VALUE refined_class = rb_refinement_module_get_refined_class(module);
543 rb_clear_method_cache(refined_class, mid);
544 rb_class_foreach_subclass(refined_class, clear_iclass_method_cache_by_id_for_refinements, mid);
545 rb_clear_all_refinement_method_cache();
546 }
547 rb_class_foreach_subclass(module, clear_iclass_method_cache_by_id, mid);
548 }
549 else {
550 clear_method_cache_by_id_in_class(klass_or_module, mid);
551 }
552}
553
554static enum rb_id_table_iterator_result
555invalidate_method_entry_in_iclass_callable_m_tbl(VALUE cme, void *data)
556{
557 vm_cme_invalidate((rb_callable_method_entry_t *)cme);
558 return ID_TABLE_DELETE;
559}
560
561static enum rb_id_table_iterator_result
562invalidate_ccs_in_iclass_cc_tbl(VALUE value, void *data)
563{
564 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)value;
565 vm_cme_invalidate((rb_callable_method_entry_t *)ccs->cme);
566 return ID_TABLE_DELETE;
567}
568
569void
570rb_invalidate_method_caches(struct rb_id_table *cm_tbl, VALUE cc_tbl)
571{
572 if (cm_tbl) {
573 rb_id_table_foreach_values(cm_tbl, invalidate_method_entry_in_iclass_callable_m_tbl, NULL);
574 }
575 if (cc_tbl) {
576 rb_managed_id_table_foreach_values(cc_tbl, invalidate_ccs_in_iclass_cc_tbl, NULL);
577 }
578}
579
580static int
581invalidate_cc_refinement(st_data_t key, st_data_t data)
582{
583 VALUE v = (VALUE)key;
584 void *ptr = rb_asan_poisoned_object_p(v);
585 rb_asan_unpoison_object(v, false);
586
587 if (rb_gc_pointer_to_heap_p(v) &&
588 !rb_objspace_garbage_object_p(v) &&
589 RBASIC(v)->flags) { // liveness check
590 const struct rb_callcache *cc = (const struct rb_callcache *)v;
591
592 VM_ASSERT(vm_cc_refinement_p(cc));
593
594 if (vm_cc_valid(cc)) {
595 vm_cc_invalidate(cc);
596 }
597 }
598
599 if (ptr) {
600 rb_asan_poison_object(v);
601 }
602
603 return ST_CONTINUE;
604}
605
606static st_index_t
607vm_ci_hash(VALUE v)
608{
609 const struct rb_callinfo *ci = (const struct rb_callinfo *)v;
610 st_index_t h;
611 h = rb_hash_start(ci->mid);
612 h = rb_hash_uint(h, ci->flag);
613 h = rb_hash_uint(h, ci->argc);
614 if (ci->kwarg) {
615 for (int i = 0; i < ci->kwarg->keyword_len; i++) {
616 h = rb_hash_uint(h, ci->kwarg->keywords[i]);
617 }
618 }
619 return h;
620}
621
622static int
623vm_ci_hash_cmp(VALUE v1, VALUE v2)
624{
625 const struct rb_callinfo *ci1 = (const struct rb_callinfo *)v1;
626 const struct rb_callinfo *ci2 = (const struct rb_callinfo *)v2;
627 if (ci1->mid != ci2->mid) return 1;
628 if (ci1->flag != ci2->flag) return 1;
629 if (ci1->argc != ci2->argc) return 1;
630 if (ci1->kwarg != NULL) {
631 VM_ASSERT(ci2->kwarg != NULL); // implied by matching flags
632
633 if (ci1->kwarg->keyword_len != ci2->kwarg->keyword_len)
634 return 1;
635
636 for (int i = 0; i < ci1->kwarg->keyword_len; i++) {
637 if (ci1->kwarg->keywords[i] != ci2->kwarg->keywords[i]) {
638 return 1;
639 }
640 }
641 }
642 else {
643 VM_ASSERT(ci2->kwarg == NULL); // implied by matching flags
644 }
645 return 0;
646}
647
648static const struct st_hash_type vm_ci_hashtype = {
649 vm_ci_hash_cmp,
650 vm_ci_hash
651};
652
653static int
654ci_lookup_i(st_data_t *key, st_data_t *value, st_data_t data, int existing)
655{
656 const struct rb_callinfo *ci = (const struct rb_callinfo *)*key;
657 st_data_t *ret = (st_data_t *)data;
658
659 if (existing) {
660 if (rb_objspace_garbage_object_p((VALUE)ci)) {
661 *ret = (st_data_t)NULL;
662 return ST_DELETE;
663 }
664 else {
665 *ret = *key;
666 return ST_STOP;
667 }
668 }
669 else {
670 *key = *value = *ret = (st_data_t)ci;
671 return ST_CONTINUE;
672 }
673}
674
675const struct rb_callinfo *
676rb_vm_ci_lookup(ID mid, unsigned int flag, unsigned int argc, const struct rb_callinfo_kwarg *kwarg)
677{
678 rb_vm_t *vm = GET_VM();
679 const struct rb_callinfo *ci = NULL;
680
681 if (kwarg) {
682 ((struct rb_callinfo_kwarg *)kwarg)->references++;
683 }
684
685 struct rb_callinfo *new_ci = IMEMO_NEW(struct rb_callinfo, imemo_callinfo, (VALUE)kwarg);
686 new_ci->mid = mid;
687 new_ci->flag = flag;
688 new_ci->argc = argc;
689
690 RB_VM_LOCKING() {
691 st_table *ci_table = vm->ci_table;
692 VM_ASSERT(ci_table);
693
694 do {
695 st_update(ci_table, (st_data_t)new_ci, ci_lookup_i, (st_data_t)&ci);
696 } while (ci == NULL);
697 }
698
699 VM_ASSERT(ci);
700
701 return ci;
702}
703
704void
705rb_vm_ci_free(const struct rb_callinfo *ci)
706{
707 ASSERT_vm_locking();
708
709 rb_vm_t *vm = GET_VM();
710
711 st_data_t key = (st_data_t)ci;
712 st_delete(vm->ci_table, &key, NULL);
713}
714
715void
716rb_vm_insert_cc_refinement(const struct rb_callcache *cc)
717{
718 st_data_t key = (st_data_t)cc;
719
720 rb_vm_t *vm = GET_VM();
721 RB_VM_LOCK_ENTER();
722 {
723 rb_set_insert(vm->cc_refinement_table, key);
724 }
725 RB_VM_LOCK_LEAVE();
726}
727
728void
729rb_vm_delete_cc_refinement(const struct rb_callcache *cc)
730{
731 ASSERT_vm_locking();
732
733 rb_vm_t *vm = GET_VM();
734 st_data_t key = (st_data_t)cc;
735
736 rb_set_table_delete(vm->cc_refinement_table, &key);
737}
738
739void
740rb_clear_all_refinement_method_cache(void)
741{
742 rb_vm_t *vm = GET_VM();
743
744 RB_VM_LOCK_ENTER();
745 {
746 rb_set_table_foreach(vm->cc_refinement_table, invalidate_cc_refinement, (st_data_t)NULL);
747 rb_set_table_clear(vm->cc_refinement_table);
748 rb_set_compact_table(vm->cc_refinement_table);
749 }
750 RB_VM_LOCK_LEAVE();
751
752 rb_yjit_invalidate_all_method_lookup_assumptions();
753}
754
755void
756rb_method_table_insert(VALUE klass, struct rb_id_table *table, ID method_id, const rb_method_entry_t *me)
757{
758 RB_VM_LOCKING() {
759 rb_method_table_insert0(klass, table, method_id, me, RB_TYPE_P(klass, T_ICLASS) && !RICLASS_OWNS_M_TBL_P(klass));
760 }
761}
762
763void
764rb_method_table_insert0(VALUE klass, struct rb_id_table *table, ID method_id, const rb_method_entry_t *me, bool iclass_shared_mtbl)
765{
766 VALUE table_owner = klass;
767 if (iclass_shared_mtbl) {
768 table_owner = RBASIC(table_owner)->klass;
769 }
770 VM_ASSERT_TYPE3(table_owner, T_CLASS, T_ICLASS, T_MODULE);
771 rb_id_table_insert(table, method_id, (VALUE)me);
772 RB_OBJ_WRITTEN(table_owner, Qundef, (VALUE)me);
773}
774
775// rb_f_notimplement has an extra trailing argument to distinguish it from other methods
776// at compile-time to override arity to be -1. But the trailing argument introduces a
777// signature mismatch between caller and callee, so rb_define_method family inserts a
778// method entry with rb_f_notimplement_internal, which has canonical arity=-1 signature,
779// instead of rb_f_notimplement.
780NORETURN(static VALUE rb_f_notimplement_internal(int argc, const VALUE *argv, VALUE obj));
781
782static VALUE
783rb_f_notimplement_internal(int argc, const VALUE *argv, VALUE obj)
784{
786
788}
789
790VALUE
791rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)
792{
793 rb_f_notimplement_internal(argc, argv, obj);
794}
795
796static void
797rb_define_notimplement_method_id(VALUE mod, ID id, rb_method_visibility_t visi)
798{
799 rb_add_method(mod, id, VM_METHOD_TYPE_NOTIMPLEMENTED, (void *)1, visi);
800}
801
802void
803rb_add_method_cfunc(VALUE klass, ID mid, VALUE (*func)(ANYARGS), int argc, rb_method_visibility_t visi)
804{
805 if (argc < -2 || 15 < argc) rb_raise(rb_eArgError, "arity out of range: %d for -2..15", argc);
806 if (func != (VALUE(*)(ANYARGS))rb_f_notimplement) {
808 opt.func = func;
809 opt.argc = argc;
810 rb_add_method(klass, mid, VM_METHOD_TYPE_CFUNC, &opt, visi);
811 }
812 else {
813 rb_define_notimplement_method_id(klass, mid, visi);
814 }
815}
816
817void
818rb_add_method_optimized(VALUE klass, ID mid, enum method_optimized_type opt_type, unsigned int index, rb_method_visibility_t visi)
819{
821 .type = opt_type,
822 .index = index,
823 };
824 rb_add_method(klass, mid, VM_METHOD_TYPE_OPTIMIZED, &opt, visi);
825}
826
827static void
828rb_method_definition_release(rb_method_definition_t *def)
829{
830 if (def != NULL) {
831 const unsigned int reference_count_was = RUBY_ATOMIC_FETCH_SUB(def->reference_count, 1);
832
833 RUBY_ASSERT_ALWAYS(reference_count_was != 0);
834
835 if (reference_count_was == 1) {
836 if (METHOD_DEBUG) fprintf(stderr, "-%p-%s:1->0 (remove)\n", (void *)def,
837 rb_id2name(def->original_id));
838 if (def->type == VM_METHOD_TYPE_BMETHOD && def->body.bmethod.hooks) {
839 xfree(def->body.bmethod.hooks);
840 }
841 xfree(def);
842 }
843 else {
844 if (METHOD_DEBUG) fprintf(stderr, "-%p-%s:%d->%d (dec)\n", (void *)def, rb_id2name(def->original_id),
845 reference_count_was, reference_count_was - 1);
846 }
847 }
848}
849
850static void delete_overloaded_cme(const rb_callable_method_entry_t *cme);
851
852void
853rb_free_method_entry_vm_weak_references(const rb_method_entry_t *me)
854{
855 if (me->def && me->def->iseq_overload) {
856 delete_overloaded_cme((const rb_callable_method_entry_t *)me);
857 }
858}
859
860void
861rb_free_method_entry(const rb_method_entry_t *me)
862{
863#if USE_ZJIT
864 if (METHOD_ENTRY_CACHED(me)) {
865 rb_zjit_cme_free((const rb_callable_method_entry_t *)me);
866 }
867#endif
868
869#if USE_YJIT
870 // YJIT rb_yjit_root_mark() roots CMEs in `Invariants`,
871 // to remove from `Invariants` here.
872#endif
873
874 rb_method_definition_release(me->def);
875}
876
877static inline rb_method_entry_t *search_method(VALUE klass, ID id, VALUE *defined_class_ptr);
878extern int rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2);
879
880static VALUE
881(*call_cfunc_invoker_func(int argc))(VALUE recv, int argc, const VALUE *, VALUE (*func)(ANYARGS))
882{
883 if (!GET_THREAD()->ext_config.ractor_safe) {
884 switch (argc) {
885 case -2: return &call_cfunc_m2;
886 case -1: return &call_cfunc_m1;
887 case 0: return &call_cfunc_0;
888 case 1: return &call_cfunc_1;
889 case 2: return &call_cfunc_2;
890 case 3: return &call_cfunc_3;
891 case 4: return &call_cfunc_4;
892 case 5: return &call_cfunc_5;
893 case 6: return &call_cfunc_6;
894 case 7: return &call_cfunc_7;
895 case 8: return &call_cfunc_8;
896 case 9: return &call_cfunc_9;
897 case 10: return &call_cfunc_10;
898 case 11: return &call_cfunc_11;
899 case 12: return &call_cfunc_12;
900 case 13: return &call_cfunc_13;
901 case 14: return &call_cfunc_14;
902 case 15: return &call_cfunc_15;
903 default:
904 rb_bug("unsupported length: %d", argc);
905 }
906 }
907 else {
908 switch (argc) {
909 case -2: return &ractor_safe_call_cfunc_m2;
910 case -1: return &ractor_safe_call_cfunc_m1;
911 case 0: return &ractor_safe_call_cfunc_0;
912 case 1: return &ractor_safe_call_cfunc_1;
913 case 2: return &ractor_safe_call_cfunc_2;
914 case 3: return &ractor_safe_call_cfunc_3;
915 case 4: return &ractor_safe_call_cfunc_4;
916 case 5: return &ractor_safe_call_cfunc_5;
917 case 6: return &ractor_safe_call_cfunc_6;
918 case 7: return &ractor_safe_call_cfunc_7;
919 case 8: return &ractor_safe_call_cfunc_8;
920 case 9: return &ractor_safe_call_cfunc_9;
921 case 10: return &ractor_safe_call_cfunc_10;
922 case 11: return &ractor_safe_call_cfunc_11;
923 case 12: return &ractor_safe_call_cfunc_12;
924 case 13: return &ractor_safe_call_cfunc_13;
925 case 14: return &ractor_safe_call_cfunc_14;
926 case 15: return &ractor_safe_call_cfunc_15;
927 default:
928 rb_bug("unsupported length: %d", argc);
929 }
930 }
931}
932
933static void
934setup_method_cfunc_struct(rb_method_cfunc_t *cfunc, VALUE (*func)(ANYARGS), int argc)
935{
936 cfunc->func = func;
937 cfunc->argc = argc;
938 cfunc->invoker = call_cfunc_invoker_func(argc);
939}
940
942method_definition_addref(rb_method_definition_t *def, bool complemented)
943{
944 unsigned int reference_count_was = RUBY_ATOMIC_FETCH_ADD(def->reference_count, 1);
945 if (!complemented && reference_count_was > 0) {
946 /* TODO: A Ractor can reach this via UnboundMethod#bind */
947 def->aliased = true;
948 }
949 if (METHOD_DEBUG) fprintf(stderr, "+%p-%s:%d->%d\n", (void *)def, rb_id2name(def->original_id), reference_count_was, reference_count_was+1);
950
951 return def;
952}
953
954void
955rb_method_definition_set(const rb_method_entry_t *me, rb_method_definition_t *def, void *opts)
956{
957 rb_method_definition_release(me->def);
958 *(rb_method_definition_t **)&me->def = method_definition_addref(def, METHOD_ENTRY_COMPLEMENTED(me));
959
960 if (!ruby_running) add_opt_method_entry(me);
961
962 if (opts != NULL) {
963 switch (def->type) {
964 case VM_METHOD_TYPE_ISEQ:
965 {
966 rb_method_iseq_t *iseq_body = (rb_method_iseq_t *)opts;
967 const rb_iseq_t *iseq = iseq_body->iseqptr;
968 rb_cref_t *method_cref, *cref = iseq_body->cref;
969
970 /* setup iseq first (before invoking GC) */
971 RB_OBJ_WRITE(me, &def->body.iseq.iseqptr, iseq);
972
973 // Methods defined in `with_jit` should be considered METHOD_ENTRY_BASIC
974 if (rb_iseq_attr_p(iseq, BUILTIN_ATTR_C_TRACE)) {
975 METHOD_ENTRY_BASIC_SET((rb_method_entry_t *)me, TRUE);
976 }
977
978 if (ISEQ_BODY(iseq)->mandatory_only_iseq) def->iseq_overload = 1;
979
980 if (0) vm_cref_dump("rb_method_definition_create", cref);
981
982 if (cref) {
983 method_cref = cref;
984 }
985 else {
986 method_cref = vm_cref_new_toplevel(GET_EC()); /* TODO: can we reuse? */
987 }
988
989 RB_OBJ_WRITE(me, &def->body.iseq.cref, method_cref);
990 return;
991 }
992 case VM_METHOD_TYPE_CFUNC:
993 {
994 rb_method_cfunc_t *cfunc = (rb_method_cfunc_t *)opts;
995 setup_method_cfunc_struct(UNALIGNED_MEMBER_PTR(def, body.cfunc), cfunc->func, cfunc->argc);
996 return;
997 }
998 case VM_METHOD_TYPE_ATTRSET:
999 case VM_METHOD_TYPE_IVAR:
1000 {
1001 const rb_execution_context_t *ec = GET_EC();
1002 rb_control_frame_t *cfp;
1003 int line;
1004
1005 def->body.attr.id = (ID)(VALUE)opts;
1006
1007 cfp = rb_vm_get_ruby_level_next_cfp(ec, ec->cfp);
1008
1009 if (cfp && (line = rb_vm_get_sourceline(cfp))) {
1010 VALUE location = rb_ary_new3(2, rb_iseq_path(cfp->iseq), INT2FIX(line));
1011 RB_OBJ_WRITE(me, &def->body.attr.location, rb_ary_freeze(location));
1012 }
1013 else {
1014 VM_ASSERT(def->body.attr.location == 0);
1015 }
1016 return;
1017 }
1018 case VM_METHOD_TYPE_BMETHOD:
1019 RB_OBJ_WRITE(me, &def->body.bmethod.proc, (VALUE)opts);
1020 RB_OBJ_WRITE(me, &def->body.bmethod.defined_ractor, rb_ractor_self(GET_RACTOR()));
1021 return;
1022 case VM_METHOD_TYPE_NOTIMPLEMENTED:
1023 setup_method_cfunc_struct(UNALIGNED_MEMBER_PTR(def, body.cfunc), (VALUE(*)(ANYARGS))rb_f_notimplement_internal, -1);
1024 return;
1025 case VM_METHOD_TYPE_OPTIMIZED:
1026 def->body.optimized = *(rb_method_optimized_t *)opts;
1027 return;
1028 case VM_METHOD_TYPE_REFINED:
1029 {
1030 RB_OBJ_WRITE(me, &def->body.refined.orig_me, (rb_method_entry_t *)opts);
1031 return;
1032 }
1033 case VM_METHOD_TYPE_ALIAS:
1034 RB_OBJ_WRITE(me, &def->body.alias.original_me, (rb_method_entry_t *)opts);
1035 return;
1036 case VM_METHOD_TYPE_ZSUPER:
1037 case VM_METHOD_TYPE_UNDEF:
1038 case VM_METHOD_TYPE_MISSING:
1039 return;
1040 }
1041 }
1042}
1043
1044static void
1045method_definition_reset(const rb_method_entry_t *me)
1046{
1047 rb_method_definition_t *def = me->def;
1048
1049 switch (def->type) {
1050 case VM_METHOD_TYPE_ISEQ:
1051 RB_OBJ_WRITTEN(me, Qundef, def->body.iseq.iseqptr);
1052 RB_OBJ_WRITTEN(me, Qundef, def->body.iseq.cref);
1053 break;
1054 case VM_METHOD_TYPE_ATTRSET:
1055 case VM_METHOD_TYPE_IVAR:
1056 RB_OBJ_WRITTEN(me, Qundef, def->body.attr.location);
1057 break;
1058 case VM_METHOD_TYPE_BMETHOD:
1059 RB_OBJ_WRITTEN(me, Qundef, def->body.bmethod.proc);
1060 RB_OBJ_WRITTEN(me, Qundef, def->body.bmethod.defined_ractor);
1061 /* give up to check all in a list */
1062 if (def->body.bmethod.hooks) rb_gc_writebarrier_remember((VALUE)me);
1063 break;
1064 case VM_METHOD_TYPE_REFINED:
1065 RB_OBJ_WRITTEN(me, Qundef, def->body.refined.orig_me);
1066 break;
1067 case VM_METHOD_TYPE_ALIAS:
1068 RB_OBJ_WRITTEN(me, Qundef, def->body.alias.original_me);
1069 break;
1070 case VM_METHOD_TYPE_CFUNC:
1071 case VM_METHOD_TYPE_ZSUPER:
1072 case VM_METHOD_TYPE_MISSING:
1073 case VM_METHOD_TYPE_OPTIMIZED:
1074 case VM_METHOD_TYPE_UNDEF:
1075 case VM_METHOD_TYPE_NOTIMPLEMENTED:
1076 break;
1077 }
1078}
1079
1080static rb_atomic_t method_serial = 1;
1081
1083rb_method_definition_create(rb_method_type_t type, ID mid)
1084{
1087 def->type = type;
1088 def->original_id = mid;
1089 def->method_serial = (uintptr_t)RUBY_ATOMIC_FETCH_ADD(method_serial, 1);
1090 def->ns = rb_current_namespace();
1091 return def;
1092}
1093
1094static rb_method_entry_t *
1095rb_method_entry_alloc(ID called_id, VALUE owner, VALUE defined_class, rb_method_definition_t *def, bool complement)
1096{
1097 if (def) method_definition_addref(def, complement);
1098 if (RTEST(defined_class)) {
1099 // not negative cache
1100 VM_ASSERT_TYPE2(defined_class, T_CLASS, T_ICLASS);
1101 }
1102 rb_method_entry_t *me = IMEMO_NEW(rb_method_entry_t, imemo_ment, defined_class);
1103 *((rb_method_definition_t **)&me->def) = def;
1104 me->called_id = called_id;
1105 me->owner = owner;
1106
1107 return me;
1108}
1109
1110static VALUE
1111filter_defined_class(VALUE klass)
1112{
1113 switch (BUILTIN_TYPE(klass)) {
1114 case T_CLASS:
1115 return klass;
1116 case T_MODULE:
1117 return 0;
1118 case T_ICLASS:
1119 break;
1120 default:
1121 break;
1122 }
1123 rb_bug("filter_defined_class: %s", rb_obj_info(klass));
1124}
1125
1127rb_method_entry_create(ID called_id, VALUE klass, rb_method_visibility_t visi, rb_method_definition_t *def)
1128{
1129 rb_method_entry_t *me = rb_method_entry_alloc(called_id, klass, filter_defined_class(klass), def, false);
1130 METHOD_ENTRY_FLAGS_SET(me, visi, ruby_running ? FALSE : TRUE);
1131 if (def != NULL) method_definition_reset(me);
1132 return me;
1133}
1134
1135// Return a cloned ME that's not invalidated (MEs are disposable for caching).
1136const rb_method_entry_t *
1137rb_method_entry_clone(const rb_method_entry_t *src_me)
1138{
1139 rb_method_entry_t *me = rb_method_entry_alloc(src_me->called_id, src_me->owner, src_me->defined_class, src_me->def, METHOD_ENTRY_COMPLEMENTED(src_me));
1140
1141 METHOD_ENTRY_FLAGS_COPY(me, src_me);
1142
1143 // Also clone inner ME in case of refinement ME
1144 if (src_me->def &&
1145 src_me->def->type == VM_METHOD_TYPE_REFINED &&
1146 src_me->def->body.refined.orig_me) {
1147 const rb_method_entry_t *orig_me = src_me->def->body.refined.orig_me;
1148 VM_ASSERT(orig_me->def->type != VM_METHOD_TYPE_REFINED);
1149
1150 rb_method_entry_t *orig_clone = rb_method_entry_alloc(orig_me->called_id,
1151 orig_me->owner, orig_me->defined_class, orig_me->def, METHOD_ENTRY_COMPLEMENTED(orig_me));
1152 METHOD_ENTRY_FLAGS_COPY(orig_clone, orig_me);
1153
1154 // Clone definition, since writing a VALUE to a shared definition
1155 // can create reference edges we can't run WBs for.
1156 rb_method_definition_t *clone_def =
1157 rb_method_definition_create(VM_METHOD_TYPE_REFINED, src_me->called_id);
1158 rb_method_definition_set(me, clone_def, orig_clone);
1159 }
1160 return me;
1161}
1162
1164rb_method_entry_complement_defined_class(const rb_method_entry_t *src_me, ID called_id, VALUE defined_class)
1165{
1166 rb_method_definition_t *def = src_me->def;
1168 const rb_method_entry_t *refined_orig_me = NULL;
1169
1170 if (!src_me->defined_class &&
1171 def->type == VM_METHOD_TYPE_REFINED &&
1172 def->body.refined.orig_me) {
1173 const rb_method_entry_t *orig_me =
1174 rb_method_entry_clone(def->body.refined.orig_me);
1175 RB_OBJ_WRITE((VALUE)orig_me, &orig_me->defined_class, defined_class);
1176 refined_orig_me = orig_me;
1177 def = NULL;
1178 }
1179
1180 me = rb_method_entry_alloc(called_id, src_me->owner, defined_class, def, true);
1181 METHOD_ENTRY_FLAGS_COPY(me, src_me);
1182 METHOD_ENTRY_COMPLEMENTED_SET(me);
1183 if (!def) {
1184 def = rb_method_definition_create(VM_METHOD_TYPE_REFINED, called_id);
1185 rb_method_definition_set(me, def, (void *)refined_orig_me);
1186 }
1187
1188 VM_ASSERT_TYPE(me->owner, T_MODULE);
1189
1190 return (rb_callable_method_entry_t *)me;
1191}
1192
1193void
1194rb_method_entry_copy(rb_method_entry_t *dst, const rb_method_entry_t *src)
1195{
1196 rb_method_definition_release(dst->def);
1197 *(rb_method_definition_t **)&dst->def = method_definition_addref(src->def, METHOD_ENTRY_COMPLEMENTED(src));
1198 method_definition_reset(dst);
1199 dst->called_id = src->called_id;
1200 RB_OBJ_WRITE((VALUE)dst, &dst->owner, src->owner);
1201 RB_OBJ_WRITE((VALUE)dst, &dst->defined_class, src->defined_class);
1202 METHOD_ENTRY_FLAGS_COPY(dst, src);
1203}
1204
1205static void
1206make_method_entry_refined(VALUE owner, rb_method_entry_t *me)
1207{
1208 if (me->def->type == VM_METHOD_TYPE_REFINED) {
1209 return;
1210 }
1211 else {
1213
1214 rb_vm_check_redefinition_opt_method(me, me->owner);
1215
1216 struct rb_method_entry_struct *orig_me =
1217 rb_method_entry_alloc(me->called_id,
1218 me->owner,
1219 me->defined_class,
1220 me->def,
1221 true);
1222 METHOD_ENTRY_FLAGS_COPY(orig_me, me);
1223
1224 def = rb_method_definition_create(VM_METHOD_TYPE_REFINED, me->called_id);
1225 rb_method_definition_set(me, def, orig_me);
1226 METHOD_ENTRY_VISI_SET(me, METHOD_VISI_PUBLIC);
1227 }
1228}
1229
1230static inline rb_method_entry_t *
1231lookup_method_table(VALUE klass, ID id)
1232{
1233 st_data_t body;
1234 struct rb_id_table *m_tbl = RCLASS_M_TBL(klass);
1235
1236 if (rb_id_table_lookup(m_tbl, id, &body)) {
1237 return (rb_method_entry_t *) body;
1238 }
1239 else {
1240 return 0;
1241 }
1242}
1243
1244void
1245rb_add_refined_method_entry(VALUE refined_class, ID mid)
1246{
1247 rb_method_entry_t *me = lookup_method_table(refined_class, mid);
1248
1249 if (me) {
1250 make_method_entry_refined(refined_class, me);
1251 rb_clear_method_cache(refined_class, mid);
1252 }
1253 else {
1254 rb_add_method(refined_class, mid, VM_METHOD_TYPE_REFINED, 0, METHOD_VISI_PUBLIC);
1255 }
1256}
1257
1258static void
1259check_override_opt_method_i(VALUE klass, VALUE arg)
1260{
1261 ID mid = (ID)arg;
1262 const rb_method_entry_t *me, *newme;
1263
1264 if (vm_redefinition_check_flag(klass)) {
1265 me = lookup_method_table(RCLASS_ORIGIN(klass), mid);
1266 if (me) {
1267 newme = rb_method_entry(klass, mid);
1268 if (newme != me) rb_vm_check_redefinition_opt_method(me, me->owner);
1269 }
1270 }
1271 rb_class_foreach_subclass(klass, check_override_opt_method_i, (VALUE)mid);
1272}
1273
1274static void
1275check_override_opt_method(VALUE klass, VALUE mid)
1276{
1277 if (rb_vm_check_optimizable_mid(mid)) {
1278 check_override_opt_method_i(klass, mid);
1279 }
1280}
1281
1282/*
1283 * klass->method_table[mid] = method_entry(defined_class, visi, def)
1284 *
1285 * If def is given (!= NULL), then just use it and ignore original_id and otps.
1286 * If not given, then make a new def with original_id and opts.
1287 */
1288static rb_method_entry_t *
1289rb_method_entry_make(VALUE klass, ID mid, VALUE defined_class, rb_method_visibility_t visi,
1290 rb_method_type_t type, rb_method_definition_t *def, ID original_id, void *opts)
1291{
1293 struct rb_id_table *mtbl;
1294 st_data_t data;
1295 int make_refined = 0;
1296 VALUE orig_klass;
1297
1298 if (NIL_P(klass)) {
1299 klass = rb_cObject;
1300 }
1301 orig_klass = klass;
1302
1303 if (!RCLASS_SINGLETON_P(klass) &&
1304 type != VM_METHOD_TYPE_NOTIMPLEMENTED &&
1305 type != VM_METHOD_TYPE_ZSUPER) {
1306 switch (mid) {
1307 case idInitialize:
1308 case idInitialize_copy:
1309 case idInitialize_clone:
1310 case idInitialize_dup:
1311 case idRespond_to_missing:
1312 visi = METHOD_VISI_PRIVATE;
1313 }
1314 }
1315
1316 if (type != VM_METHOD_TYPE_REFINED) {
1317 rb_class_modify_check(klass);
1318 }
1319
1320 if (RB_TYPE_P(klass, T_MODULE) && FL_TEST(klass, RMODULE_IS_REFINEMENT)) {
1321 VALUE refined_class = rb_refinement_module_get_refined_class(klass);
1322 rb_add_refined_method_entry(refined_class, mid);
1323 }
1324 if (type == VM_METHOD_TYPE_REFINED) {
1325 rb_method_entry_t *old_me = lookup_method_table(RCLASS_ORIGIN(klass), mid);
1326 if (old_me) rb_vm_check_redefinition_opt_method(old_me, klass);
1327 }
1328 else {
1329 klass = RCLASS_ORIGIN(klass);
1330 if (klass != orig_klass) {
1331 rb_clear_method_cache(orig_klass, mid);
1332 }
1333 }
1334 mtbl = RCLASS_WRITABLE_M_TBL(klass);
1335
1336 /* check re-definition */
1337 if (rb_id_table_lookup(mtbl, mid, &data)) {
1338 rb_method_entry_t *old_me = (rb_method_entry_t *)data;
1339 rb_method_definition_t *old_def = old_me->def;
1340
1341 if (rb_method_definition_eq(old_def, def)) return old_me;
1342 rb_vm_check_redefinition_opt_method(old_me, klass);
1343
1344 if (old_def->type == VM_METHOD_TYPE_REFINED) make_refined = 1;
1345
1346 if (RTEST(ruby_verbose) &&
1347 type != VM_METHOD_TYPE_UNDEF &&
1348 (old_def->aliased == false) &&
1349 (!old_def->no_redef_warning) &&
1350 !make_refined &&
1351 old_def->type != VM_METHOD_TYPE_UNDEF &&
1352 old_def->type != VM_METHOD_TYPE_ZSUPER &&
1353 old_def->type != VM_METHOD_TYPE_ALIAS) {
1354 const rb_iseq_t *iseq = 0;
1355
1356 switch (old_def->type) {
1357 case VM_METHOD_TYPE_ISEQ:
1358 iseq = def_iseq_ptr(old_def);
1359 break;
1360 case VM_METHOD_TYPE_BMETHOD:
1361 iseq = rb_proc_get_iseq(old_def->body.bmethod.proc, 0);
1362 break;
1363 default:
1364 break;
1365 }
1366 if (iseq) {
1367 rb_warning(
1368 "method redefined; discarding old %"PRIsVALUE"\n%s:%d: warning: previous definition of %"PRIsVALUE" was here",
1369 rb_id2str(mid),
1370 RSTRING_PTR(rb_iseq_path(iseq)),
1371 ISEQ_BODY(iseq)->location.first_lineno,
1372 rb_id2str(old_def->original_id)
1373 );
1374 }
1375 else {
1376 rb_warning("method redefined; discarding old %"PRIsVALUE, rb_id2str(mid));
1377 }
1378 }
1379 }
1380
1381 /* create method entry */
1382 me = rb_method_entry_create(mid, defined_class, visi, NULL);
1383 if (def == NULL) {
1384 def = rb_method_definition_create(type, original_id);
1385 }
1386 rb_method_definition_set(me, def, opts);
1387
1388 rb_clear_method_cache(klass, mid);
1389
1390 /* check mid */
1391 if (klass == rb_cObject) {
1392 switch (mid) {
1393 case idInitialize:
1394 case idRespond_to_missing:
1395 case idMethodMissing:
1396 case idRespond_to:
1397 rb_warn("redefining Object#%s may cause infinite loop", rb_id2name(mid));
1398 }
1399 }
1400 /* check mid */
1401 if (mid == object_id || mid == id__id__ || mid == id__send__) {
1402 if (type != VM_METHOD_TYPE_CFUNC && search_method(klass, mid, 0)) {
1403 rb_warn("redefining '%s' may cause serious problems", rb_id2name(mid));
1404 }
1405 }
1406
1407 if (make_refined) {
1408 make_method_entry_refined(klass, me);
1409 }
1410
1411 rb_method_table_insert(klass, mtbl, mid, me);
1412
1413 VM_ASSERT(me->def != NULL);
1414
1415 /* check optimized method override by a prepended module */
1416 if (RB_TYPE_P(orig_klass, T_MODULE)) {
1417 check_override_opt_method(klass, (VALUE)mid);
1418 }
1419
1420 return me;
1421}
1422
1423static st_table *
1424overloaded_cme_table(void)
1425{
1426 VM_ASSERT(GET_VM()->overloaded_cme_table != NULL);
1427 return GET_VM()->overloaded_cme_table;
1428}
1429
1430#if VM_CHECK_MODE > 0
1431static int
1432vm_dump_overloaded_cme_table(st_data_t key, st_data_t val, st_data_t dmy)
1433{
1434 fprintf(stderr, "key: "); rp(key);
1435 fprintf(stderr, "val: "); rp(val);
1436 return ST_CONTINUE;
1437}
1438
1439void
1440rb_vm_dump_overloaded_cme_table(void)
1441{
1442 fprintf(stderr, "== rb_vm_dump_overloaded_cme_table\n");
1443 st_foreach(overloaded_cme_table(), vm_dump_overloaded_cme_table, 0);
1444}
1445#endif
1446
1447static int
1448lookup_overloaded_cme_i(st_data_t *key, st_data_t *value, st_data_t data, int existing)
1449{
1450 if (existing) {
1451 const rb_callable_method_entry_t *cme = (const rb_callable_method_entry_t *)*key;
1452 const rb_callable_method_entry_t *monly_cme = (const rb_callable_method_entry_t *)*value;
1453 const rb_callable_method_entry_t **ptr = (const rb_callable_method_entry_t **)data;
1454
1455 if (rb_objspace_garbage_object_p((VALUE)cme) ||
1456 rb_objspace_garbage_object_p((VALUE)monly_cme)) {
1457 *ptr = NULL;
1458 return ST_DELETE;
1459 }
1460 else {
1461 *ptr = monly_cme;
1462 }
1463 }
1464
1465 return ST_STOP;
1466}
1467
1468static const rb_callable_method_entry_t *
1469lookup_overloaded_cme(const rb_callable_method_entry_t *cme)
1470{
1471 ASSERT_vm_locking();
1472
1473 const rb_callable_method_entry_t *monly_cme = NULL;
1474 st_update(overloaded_cme_table(), (st_data_t)cme, lookup_overloaded_cme_i, (st_data_t)&monly_cme);
1475 return monly_cme;
1476}
1477
1478#if VM_CHECK_MODE > 0
1480rb_vm_lookup_overloaded_cme(const rb_callable_method_entry_t *cme)
1481{
1482 return lookup_overloaded_cme(cme);
1483}
1484#endif
1485
1486static void
1487delete_overloaded_cme(const rb_callable_method_entry_t *cme)
1488{
1489 st_data_t cme_data = (st_data_t)cme;
1490 ASSERT_vm_locking();
1491 st_delete(overloaded_cme_table(), &cme_data, NULL);
1492}
1493
1494static const rb_callable_method_entry_t *
1495get_overloaded_cme(const rb_callable_method_entry_t *cme)
1496{
1497 const rb_callable_method_entry_t *monly_cme = lookup_overloaded_cme(cme);
1498
1499 if (monly_cme && !METHOD_ENTRY_INVALIDATED(monly_cme)) {
1500 return monly_cme;
1501 }
1502 else {
1503 // create
1504 rb_method_definition_t *def = rb_method_definition_create(VM_METHOD_TYPE_ISEQ, cme->def->original_id);
1505 rb_method_entry_t *me = rb_method_entry_alloc(cme->called_id,
1506 cme->owner,
1507 cme->defined_class,
1508 def,
1509 false);
1510
1511 RB_OBJ_WRITE(me, &def->body.iseq.cref, cme->def->body.iseq.cref);
1512 RB_OBJ_WRITE(me, &def->body.iseq.iseqptr, ISEQ_BODY(cme->def->body.iseq.iseqptr)->mandatory_only_iseq);
1513
1514 ASSERT_vm_locking();
1515 st_insert(overloaded_cme_table(), (st_data_t)cme, (st_data_t)me);
1516
1517 METHOD_ENTRY_VISI_SET(me, METHOD_ENTRY_VISI(cme));
1518 return (rb_callable_method_entry_t *)me;
1519 }
1520}
1521
1523rb_check_overloaded_cme(const rb_callable_method_entry_t *cme, const struct rb_callinfo * const ci)
1524{
1525 if (UNLIKELY(cme->def->iseq_overload) &&
1526 (vm_ci_flag(ci) & (VM_CALL_ARGS_SIMPLE)) &&
1527 (!(vm_ci_flag(ci) & VM_CALL_FORWARDING)) &&
1528 (int)vm_ci_argc(ci) == ISEQ_BODY(method_entry_iseqptr(cme))->param.lead_num) {
1529 VM_ASSERT(cme->def->type == VM_METHOD_TYPE_ISEQ, "type: %d", cme->def->type); // iseq_overload is marked only on ISEQ methods
1530
1531 cme = get_overloaded_cme(cme);
1532
1533 VM_ASSERT(cme != NULL);
1534 METHOD_ENTRY_CACHED_SET((struct rb_callable_method_entry_struct *)cme);
1535 }
1536
1537 return cme;
1538}
1539
1540#define CALL_METHOD_HOOK(klass, hook, mid) do { \
1541 const VALUE arg = ID2SYM(mid); \
1542 VALUE recv_class = (klass); \
1543 ID hook_id = (hook); \
1544 if (RCLASS_SINGLETON_P((klass))) { \
1545 recv_class = RCLASS_ATTACHED_OBJECT((klass)); \
1546 hook_id = singleton_##hook; \
1547 } \
1548 rb_funcallv(recv_class, hook_id, 1, &arg); \
1549 } while (0)
1550
1551static void
1552method_added(VALUE klass, ID mid)
1553{
1554 if (ruby_running) {
1555 CALL_METHOD_HOOK(klass, added, mid);
1556 }
1557}
1558
1559void
1560rb_add_method(VALUE klass, ID mid, rb_method_type_t type, void *opts, rb_method_visibility_t visi)
1561{
1562 RB_VM_LOCKING() {
1563 rb_method_entry_make(klass, mid, klass, visi, type, NULL, mid, opts);
1564 }
1565
1566 if (type != VM_METHOD_TYPE_UNDEF && type != VM_METHOD_TYPE_REFINED) {
1567 method_added(klass, mid);
1568 }
1569}
1570
1571void
1572rb_add_method_iseq(VALUE klass, ID mid, const rb_iseq_t *iseq, rb_cref_t *cref, rb_method_visibility_t visi)
1573{
1574 struct { /* should be same fields with rb_method_iseq_struct */
1575 const rb_iseq_t *iseqptr;
1576 rb_cref_t *cref;
1577 } iseq_body;
1578
1579 iseq_body.iseqptr = iseq;
1580 iseq_body.cref = cref;
1581
1582 rb_add_method(klass, mid, VM_METHOD_TYPE_ISEQ, &iseq_body, visi);
1583}
1584
1585static rb_method_entry_t *
1586method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *me,
1587 rb_method_visibility_t visi, VALUE defined_class)
1588{
1589 rb_method_entry_t *newme;
1590 RB_VM_LOCKING() {
1591 newme = rb_method_entry_make(klass, mid, defined_class, visi,
1592 me->def->type, me->def, 0, NULL);
1593 if (newme == me) {
1594 me->def->no_redef_warning = TRUE;
1595 METHOD_ENTRY_FLAGS_SET(newme, visi, FALSE);
1596 }
1597 }
1598
1599 method_added(klass, mid);
1600 return newme;
1601}
1602
1604rb_method_entry_set(VALUE klass, ID mid, const rb_method_entry_t *me, rb_method_visibility_t visi)
1605{
1606 return method_entry_set(klass, mid, me, visi, klass);
1607}
1608
1609#define UNDEF_ALLOC_FUNC ((rb_alloc_func_t)-1)
1610
1611void
1612rb_define_alloc_func(VALUE klass, VALUE (*func)(VALUE))
1613{
1614 Check_Type(klass, T_CLASS);
1615 if (RCLASS_SINGLETON_P(klass)) {
1616 rb_raise(rb_eTypeError, "can't define an allocator for a singleton class");
1617 }
1618 RCLASS_SET_ALLOCATOR(klass, func);
1619}
1620
1621void
1623{
1624 rb_define_alloc_func(klass, UNDEF_ALLOC_FUNC);
1625}
1626
1629{
1630 Check_Type(klass, T_CLASS);
1631
1632 for (; klass; klass = RCLASS_SUPER(klass)) {
1633 rb_alloc_func_t allocator = RCLASS_ALLOCATOR(klass);
1634 if (allocator == UNDEF_ALLOC_FUNC) break;
1635 if (allocator) return allocator;
1636 }
1637 return 0;
1638}
1639
1640const rb_method_entry_t *
1641rb_method_entry_at(VALUE klass, ID id)
1642{
1643 return lookup_method_table(klass, id);
1644}
1645
1646static inline rb_method_entry_t*
1647search_method0(VALUE klass, ID id, VALUE *defined_class_ptr, bool skip_refined)
1648{
1649 rb_method_entry_t *me = NULL;
1650
1651 RB_DEBUG_COUNTER_INC(mc_search);
1652
1653 for (; klass; klass = RCLASS_SUPER(klass)) {
1654 RB_DEBUG_COUNTER_INC(mc_search_super);
1655 if ((me = lookup_method_table(klass, id)) != 0) {
1656 if (!skip_refined || me->def->type != VM_METHOD_TYPE_REFINED ||
1657 me->def->body.refined.orig_me) {
1658 break;
1659 }
1660 }
1661 }
1662
1663 if (defined_class_ptr) *defined_class_ptr = klass;
1664
1665 if (me == NULL) RB_DEBUG_COUNTER_INC(mc_search_notfound);
1666
1667 VM_ASSERT(me == NULL || !METHOD_ENTRY_INVALIDATED(me),
1668 "invalid me, mid:%s, klass:%s(%s)",
1669 rb_id2name(id),
1670 RTEST(rb_mod_name(klass)) ? RSTRING_PTR(rb_mod_name(klass)) : "anonymous",
1671 rb_obj_info(klass));
1672 return me;
1673}
1674
1675static inline rb_method_entry_t*
1676search_method(VALUE klass, ID id, VALUE *defined_class_ptr)
1677{
1678 return search_method0(klass, id, defined_class_ptr, false);
1679}
1680
1681static rb_method_entry_t *
1682search_method_protect(VALUE klass, ID id, VALUE *defined_class_ptr)
1683{
1684 rb_method_entry_t *me = search_method(klass, id, defined_class_ptr);
1685
1686 if (!UNDEFINED_METHOD_ENTRY_P(me)) {
1687 return me;
1688 }
1689 else {
1690 return NULL;
1691 }
1692}
1693
1694const rb_method_entry_t *
1695rb_method_entry(VALUE klass, ID id)
1696{
1697 return search_method_protect(klass, id, NULL);
1698}
1699
1700static inline const rb_callable_method_entry_t *
1701prepare_callable_method_entry(VALUE defined_class, ID id, const rb_method_entry_t * const me, int create)
1702{
1703 struct rb_id_table *mtbl;
1704 const rb_callable_method_entry_t *cme;
1705 VALUE cme_data;
1706 int cme_found = 0;
1707
1708 if (me) {
1709 if (me->defined_class == 0) {
1710 RB_DEBUG_COUNTER_INC(mc_cme_complement);
1711 VM_ASSERT_TYPE2(defined_class, T_ICLASS, T_MODULE);
1712
1713 mtbl = RCLASS_WRITABLE_CALLABLE_M_TBL(defined_class);
1714 if (mtbl && rb_id_table_lookup(mtbl, id, &cme_data)) {
1715 cme = (rb_callable_method_entry_t *)cme_data;
1716 cme_found = 1;
1717 }
1718 if (cme_found) {
1719 RB_DEBUG_COUNTER_INC(mc_cme_complement_hit);
1720 VM_ASSERT(callable_method_entry_p(cme));
1721 VM_ASSERT(!METHOD_ENTRY_INVALIDATED(cme));
1722 }
1723 else if (create) {
1724 if (!mtbl) {
1725 mtbl = rb_id_table_create(0);
1726 RCLASS_WRITE_CALLABLE_M_TBL(defined_class, mtbl);
1727 }
1728 cme = rb_method_entry_complement_defined_class(me, me->called_id, defined_class);
1729 rb_id_table_insert(mtbl, id, (VALUE)cme);
1730 RB_OBJ_WRITTEN(defined_class, Qundef, (VALUE)cme);
1731 VM_ASSERT(callable_method_entry_p(cme));
1732 }
1733 else {
1734 return NULL;
1735 }
1736 }
1737 else {
1738 cme = (const rb_callable_method_entry_t *)me;
1739 VM_ASSERT(callable_method_entry_p(cme));
1740 VM_ASSERT(!METHOD_ENTRY_INVALIDATED(cme));
1741 }
1742 return cme;
1743 }
1744 else {
1745 return NULL;
1746 }
1747}
1748
1749static const rb_callable_method_entry_t *
1750complemented_callable_method_entry(VALUE klass, ID id)
1751{
1752 VALUE defined_class;
1753 rb_method_entry_t *me = search_method(klass, id, &defined_class);
1754 return prepare_callable_method_entry(defined_class, id, me, FALSE);
1755}
1756
1757static const rb_callable_method_entry_t *
1758cached_callable_method_entry(VALUE klass, ID mid)
1759{
1760 ASSERT_vm_locking();
1761
1762 VALUE cc_tbl = RCLASS_WRITABLE_CC_TBL(klass);
1763 VALUE ccs_data;
1764
1765 if (cc_tbl && rb_managed_id_table_lookup(cc_tbl, mid, &ccs_data)) {
1766 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_data;
1767 VM_ASSERT(vm_ccs_p(ccs));
1768
1769 if (LIKELY(!METHOD_ENTRY_INVALIDATED(ccs->cme))) {
1770 VM_ASSERT(ccs->cme->called_id == mid);
1771 RB_DEBUG_COUNTER_INC(ccs_found);
1772 return ccs->cme;
1773 }
1774 else {
1775 rb_vm_barrier();
1776
1777 rb_managed_id_table_delete(cc_tbl, mid);
1778 rb_vm_ccs_invalidate_and_free(ccs);
1779 }
1780 }
1781
1782 RB_DEBUG_COUNTER_INC(ccs_not_found);
1783 return NULL;
1784}
1785
1786static void
1787cache_callable_method_entry(VALUE klass, ID mid, const rb_callable_method_entry_t *cme)
1788{
1789 ASSERT_vm_locking();
1790 VM_ASSERT(cme != NULL);
1791
1792 VALUE cc_tbl = RCLASS_WRITABLE_CC_TBL(klass);
1793 VALUE ccs_data;
1794
1795 if (!cc_tbl) {
1796 cc_tbl = rb_vm_cc_table_create(2);
1797 RCLASS_WRITE_CC_TBL(klass, cc_tbl);
1798 }
1799
1800 if (rb_managed_id_table_lookup(cc_tbl, mid, &ccs_data)) {
1801#if VM_CHECK_MODE > 0
1802 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_data;
1803 VM_ASSERT(ccs->cme == cme);
1804#endif
1805 }
1806 else {
1807 if (rb_multi_ractor_p()) {
1808 VALUE new_cc_tbl = rb_vm_cc_table_dup(cc_tbl);
1809 vm_ccs_create(klass, new_cc_tbl, mid, cme);
1810 RB_OBJ_ATOMIC_WRITE(klass, &RCLASSEXT_CC_TBL(RCLASS_EXT_WRITABLE(klass)), new_cc_tbl);
1811 }
1812 else {
1813 vm_ccs_create(klass, cc_tbl, mid, cme);
1814 }
1815 }
1816}
1817
1818static const rb_callable_method_entry_t *
1819negative_cme(ID mid)
1820{
1821 rb_vm_t *vm = GET_VM();
1822 const rb_callable_method_entry_t *cme;
1823 VALUE cme_data;
1824
1825 if (rb_id_table_lookup(vm->negative_cme_table, mid, &cme_data)) {
1826 cme = (rb_callable_method_entry_t *)cme_data;
1827 }
1828 else {
1829 cme = (rb_callable_method_entry_t *)rb_method_entry_alloc(mid, Qnil, Qnil, NULL, false);
1830 rb_id_table_insert(vm->negative_cme_table, mid, (VALUE)cme);
1831 }
1832
1833 VM_ASSERT(cme != NULL);
1834 return cme;
1835}
1836
1837static const rb_callable_method_entry_t *
1838callable_method_entry_or_negative(VALUE klass, ID mid, VALUE *defined_class_ptr)
1839{
1840 const rb_callable_method_entry_t *cme;
1841
1842 VM_ASSERT_TYPE2(klass, T_CLASS, T_ICLASS);
1843
1844 /* Fast path: lock-free read from cache */
1845 VALUE cc_tbl = RUBY_ATOMIC_VALUE_LOAD(RCLASS_WRITABLE_CC_TBL(klass));
1846 if (cc_tbl) {
1847 VALUE ccs_data;
1848 if (rb_managed_id_table_lookup(cc_tbl, mid, &ccs_data)) {
1849 struct rb_class_cc_entries *ccs = (struct rb_class_cc_entries *)ccs_data;
1850 VM_ASSERT(vm_ccs_p(ccs));
1851
1852 if (LIKELY(!METHOD_ENTRY_INVALIDATED(ccs->cme))) {
1853 VM_ASSERT(ccs->cme->called_id == mid);
1854 if (defined_class_ptr != NULL) *defined_class_ptr = ccs->cme->defined_class;
1855 RB_DEBUG_COUNTER_INC(ccs_found);
1856 return ccs->cme;
1857 }
1858 }
1859 }
1860
1861 /* Slow path: need to lock and potentially populate cache */
1862 RB_VM_LOCKING() {
1863 cme = cached_callable_method_entry(klass, mid);
1864
1865 if (cme) {
1866 if (defined_class_ptr != NULL) *defined_class_ptr = cme->defined_class;
1867 }
1868 else {
1869 VALUE defined_class;
1870 rb_method_entry_t *me = search_method(klass, mid, &defined_class);
1871 if (defined_class_ptr) *defined_class_ptr = defined_class;
1872
1873 if (me != NULL) {
1874 cme = prepare_callable_method_entry(defined_class, mid, me, TRUE);
1875 }
1876 else {
1877 cme = negative_cme(mid);
1878 }
1879
1880 cache_callable_method_entry(klass, mid, cme);
1881 }
1882 }
1883
1884 return cme;
1885}
1886
1887// This is exposed for YJIT so that we can make assumptions that methods are
1888// not defined.
1890rb_callable_method_entry_or_negative(VALUE klass, ID mid)
1891{
1892 return callable_method_entry_or_negative(klass, mid, NULL);
1893}
1894
1895static const rb_callable_method_entry_t *
1896callable_method_entry(VALUE klass, ID mid, VALUE *defined_class_ptr)
1897{
1898 const rb_callable_method_entry_t *cme;
1899 cme = callable_method_entry_or_negative(klass, mid, defined_class_ptr);
1900 return !UNDEFINED_METHOD_ENTRY_P(cme) ? cme : NULL;
1901}
1902
1904rb_callable_method_entry(VALUE klass, ID mid)
1905{
1906 return callable_method_entry(klass, mid, NULL);
1907}
1908
1909static const rb_method_entry_t *resolve_refined_method(VALUE refinements, const rb_method_entry_t *me, VALUE *defined_class_ptr);
1910
1911static const rb_method_entry_t *
1912method_entry_resolve_refinement(VALUE klass, ID id, int with_refinement, VALUE *defined_class_ptr)
1913{
1914 const rb_method_entry_t *me = search_method_protect(klass, id, defined_class_ptr);
1915
1916 if (me) {
1917 if (me->def->type == VM_METHOD_TYPE_REFINED) {
1918 if (with_refinement) {
1919 const rb_cref_t *cref = rb_vm_cref();
1920 VALUE refinements = cref ? CREF_REFINEMENTS(cref) : Qnil;
1921 me = resolve_refined_method(refinements, me, defined_class_ptr);
1922 }
1923 else {
1924 me = resolve_refined_method(Qnil, me, defined_class_ptr);
1925 }
1926
1927 if (UNDEFINED_METHOD_ENTRY_P(me)) me = NULL;
1928 }
1929 }
1930
1931 return me;
1932}
1933
1934const rb_method_entry_t *
1935rb_method_entry_with_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)
1936{
1937 return method_entry_resolve_refinement(klass, id, TRUE, defined_class_ptr);
1938}
1939
1940static const rb_callable_method_entry_t *
1941callable_method_entry_refinements0(VALUE klass, ID id, VALUE *defined_class_ptr, bool with_refinements,
1942 const rb_callable_method_entry_t *cme)
1943{
1944 if (cme == NULL || LIKELY(cme->def->type != VM_METHOD_TYPE_REFINED)) {
1945 return cme;
1946 }
1947 else {
1948 VALUE defined_class, *dcp = defined_class_ptr ? defined_class_ptr : &defined_class;
1949 const rb_method_entry_t *me = method_entry_resolve_refinement(klass, id, with_refinements, dcp);
1950 return prepare_callable_method_entry(*dcp, id, me, TRUE);
1951 }
1952}
1953
1954static const rb_callable_method_entry_t *
1955callable_method_entry_refinements(VALUE klass, ID id, VALUE *defined_class_ptr, bool with_refinements)
1956{
1957 const rb_callable_method_entry_t *cme = callable_method_entry(klass, id, defined_class_ptr);
1958 return callable_method_entry_refinements0(klass, id, defined_class_ptr, with_refinements, cme);
1959}
1960
1962rb_callable_method_entry_with_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)
1963{
1964 return callable_method_entry_refinements(klass, id, defined_class_ptr, true);
1965}
1966
1967static const rb_callable_method_entry_t *
1968callable_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)
1969{
1970 return callable_method_entry_refinements(klass, id, defined_class_ptr, false);
1971}
1972
1973const rb_method_entry_t *
1974rb_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)
1975{
1976 return method_entry_resolve_refinement(klass, id, FALSE, defined_class_ptr);
1977}
1978
1980rb_callable_method_entry_without_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)
1981{
1982 VALUE defined_class, *dcp = defined_class_ptr ? defined_class_ptr : &defined_class;
1983 const rb_method_entry_t *me = method_entry_resolve_refinement(klass, id, FALSE, dcp);
1984 return prepare_callable_method_entry(*dcp, id, me, TRUE);
1985}
1986
1987static const rb_method_entry_t *
1988resolve_refined_method(VALUE refinements, const rb_method_entry_t *me, VALUE *defined_class_ptr)
1989{
1990 while (me && me->def->type == VM_METHOD_TYPE_REFINED) {
1991 VALUE refinement;
1992 const rb_method_entry_t *tmp_me;
1993 VALUE super;
1994
1995 refinement = find_refinement(refinements, me->owner);
1996 if (!NIL_P(refinement)) {
1997 tmp_me = search_method_protect(refinement, me->called_id, defined_class_ptr);
1998
1999 if (tmp_me && tmp_me->def->type != VM_METHOD_TYPE_REFINED) {
2000 return tmp_me;
2001 }
2002 }
2003
2004 tmp_me = me->def->body.refined.orig_me;
2005 if (tmp_me) {
2006 if (defined_class_ptr) *defined_class_ptr = tmp_me->defined_class;
2007 return tmp_me;
2008 }
2009
2010 super = RCLASS_SUPER(me->owner);
2011 if (!super) {
2012 return 0;
2013 }
2014
2015 me = search_method_protect(super, me->called_id, defined_class_ptr);
2016 }
2017 return me;
2018}
2019
2020const rb_method_entry_t *
2021rb_resolve_refined_method(VALUE refinements, const rb_method_entry_t *me)
2022{
2023 return resolve_refined_method(refinements, me, NULL);
2024}
2025
2027rb_resolve_refined_method_callable(VALUE refinements, const rb_callable_method_entry_t *me)
2028{
2029 VALUE defined_class = me->defined_class;
2030 const rb_method_entry_t *resolved_me = resolve_refined_method(refinements, (const rb_method_entry_t *)me, &defined_class);
2031
2032 if (resolved_me && resolved_me->defined_class == 0) {
2033 return rb_method_entry_complement_defined_class(resolved_me, me->called_id, defined_class);
2034 }
2035 else {
2036 return (const rb_callable_method_entry_t *)resolved_me;
2037 }
2038}
2039
2040static void
2041remove_method(VALUE klass, ID mid)
2042{
2043 VALUE data;
2044 rb_method_entry_t *me = 0;
2045 VALUE self = klass;
2046
2047 rb_class_modify_check(klass);
2048 klass = RCLASS_ORIGIN(klass);
2049 if (mid == object_id || mid == id__id__ || mid == id__send__ || mid == idInitialize) {
2050 rb_warn("removing '%s' may cause serious problems", rb_id2name(mid));
2051 }
2052
2053 if (!rb_id_table_lookup(RCLASS_M_TBL(klass), mid, &data) ||
2054 !(me = (rb_method_entry_t *)data) ||
2055 (!me->def || me->def->type == VM_METHOD_TYPE_UNDEF) ||
2056 UNDEFINED_REFINED_METHOD_P(me->def)) {
2057 rb_name_err_raise("method '%1$s' not defined in %2$s",
2058 klass, ID2SYM(mid));
2059 }
2060
2061 if (klass != self) {
2062 rb_clear_method_cache(self, mid);
2063 }
2064 rb_clear_method_cache(klass, mid);
2065 rb_id_table_delete(RCLASS_WRITABLE_M_TBL(klass), mid);
2066
2067 rb_vm_check_redefinition_opt_method(me, klass);
2068
2069 if (me->def->type == VM_METHOD_TYPE_REFINED) {
2070 rb_add_refined_method_entry(klass, mid);
2071 }
2072
2073 CALL_METHOD_HOOK(self, removed, mid);
2074}
2075
2076void
2078{
2079 remove_method(klass, mid);
2080}
2081
2082void
2083rb_remove_method(VALUE klass, const char *name)
2084{
2085 remove_method(klass, rb_intern(name));
2086}
2087
2088/*
2089 * call-seq:
2090 * remove_method(symbol) -> self
2091 * remove_method(string) -> self
2092 *
2093 * Removes the method identified by _symbol_ from the current
2094 * class. For an example, see Module#undef_method.
2095 * String arguments are converted to symbols.
2096 */
2097
2098static VALUE
2099rb_mod_remove_method(int argc, VALUE *argv, VALUE mod)
2100{
2101 int i;
2102
2103 for (i = 0; i < argc; i++) {
2104 VALUE v = argv[i];
2105 ID id = rb_check_id(&v);
2106 if (!id) {
2107 rb_name_err_raise("method '%1$s' not defined in %2$s",
2108 mod, v);
2109 }
2110 remove_method(mod, id);
2111 }
2112 return mod;
2113}
2114
2115static void
2116rb_export_method(VALUE klass, ID name, rb_method_visibility_t visi)
2117{
2119 VALUE defined_class;
2120 VALUE origin_class = RCLASS_ORIGIN(klass);
2121
2122 me = search_method0(origin_class, name, &defined_class, true);
2123
2124 if (!me && RB_TYPE_P(klass, T_MODULE)) {
2125 me = search_method(rb_cObject, name, &defined_class);
2126 }
2127
2128 if (UNDEFINED_METHOD_ENTRY_P(me) ||
2129 UNDEFINED_REFINED_METHOD_P(me->def)) {
2130 rb_print_undef(klass, name, METHOD_VISI_UNDEF);
2131 }
2132
2133 if (METHOD_ENTRY_VISI(me) != visi) {
2134 rb_vm_check_redefinition_opt_method(me, klass);
2135
2136 if (klass == defined_class || origin_class == defined_class) {
2137 if (me->def->type == VM_METHOD_TYPE_REFINED) {
2138 // Refinement method entries should always be public because the refinement
2139 // search is always performed.
2140 if (me->def->body.refined.orig_me) {
2141 METHOD_ENTRY_VISI_SET((rb_method_entry_t *)me->def->body.refined.orig_me, visi);
2142 }
2143 }
2144 else {
2145 METHOD_ENTRY_VISI_SET(me, visi);
2146 }
2147 rb_clear_method_cache(klass, name);
2148 }
2149 else {
2150 rb_add_method(klass, name, VM_METHOD_TYPE_ZSUPER, 0, visi);
2151 }
2152 }
2153}
2154
2155#define BOUND_PRIVATE 0x01
2156#define BOUND_RESPONDS 0x02
2157
2158static int
2159method_boundp(VALUE klass, ID id, int ex)
2160{
2161 const rb_callable_method_entry_t *cme;
2162
2163 VM_ASSERT_TYPE2(klass, T_CLASS, T_ICLASS);
2164
2165 if (ex & BOUND_RESPONDS) {
2166 cme = rb_callable_method_entry_with_refinements(klass, id, NULL);
2167 }
2168 else {
2169 cme = callable_method_entry_without_refinements(klass, id, NULL);
2170 }
2171
2172 if (cme != NULL) {
2173 if (ex & ~BOUND_RESPONDS) {
2174 switch (METHOD_ENTRY_VISI(cme)) {
2175 case METHOD_VISI_PRIVATE:
2176 return 0;
2177 case METHOD_VISI_PROTECTED:
2178 if (ex & BOUND_RESPONDS) return 0;
2179 default:
2180 break;
2181 }
2182 }
2183
2184 if (cme->def->type == VM_METHOD_TYPE_NOTIMPLEMENTED) {
2185 if (ex & BOUND_RESPONDS) return 2;
2186 return 0;
2187 }
2188 return 1;
2189 }
2190 return 0;
2191}
2192
2193// deprecated
2194int
2195rb_method_boundp(VALUE klass, ID id, int ex)
2196{
2197 return method_boundp(klass, id, ex);
2198}
2199
2200static void
2201vm_cref_set_visibility(rb_method_visibility_t method_visi, int module_func)
2202{
2203 rb_scope_visibility_t *scope_visi = (rb_scope_visibility_t *)&rb_vm_cref()->scope_visi;
2204 scope_visi->method_visi = method_visi;
2205 scope_visi->module_func = module_func;
2206}
2207
2208void
2209rb_scope_visibility_set(rb_method_visibility_t visi)
2210{
2211 vm_cref_set_visibility(visi, FALSE);
2212}
2213
2214static void
2215scope_visibility_check(void)
2216{
2217 /* Check for public/protected/private/module_function called inside a method */
2218 rb_control_frame_t *cfp = GET_EC()->cfp+1;
2219 if (cfp && cfp->iseq && ISEQ_BODY(cfp->iseq)->type == ISEQ_TYPE_METHOD) {
2220 rb_warn("calling %s without arguments inside a method may not have the intended effect",
2221 rb_id2name(rb_frame_this_func()));
2222 }
2223}
2224
2225static void
2226rb_scope_module_func_set(void)
2227{
2228 scope_visibility_check();
2229 vm_cref_set_visibility(METHOD_VISI_PRIVATE, TRUE);
2230}
2231
2232const rb_cref_t *rb_vm_cref_in_context(VALUE self, VALUE cbase);
2233void
2234rb_attr(VALUE klass, ID id, int read, int write, int ex)
2235{
2236 ID attriv;
2237 rb_method_visibility_t visi;
2238 const rb_execution_context_t *ec = GET_EC();
2239 const rb_cref_t *cref = rb_vm_cref_in_context(klass, klass);
2240
2241 if (!ex || !cref) {
2242 visi = METHOD_VISI_PUBLIC;
2243 }
2244 else {
2245 switch (vm_scope_visibility_get(ec)) {
2246 case METHOD_VISI_PRIVATE:
2247 if (vm_scope_module_func_check(ec)) {
2248 rb_warning("attribute accessor as module_function");
2249 }
2250 visi = METHOD_VISI_PRIVATE;
2251 break;
2252 case METHOD_VISI_PROTECTED:
2253 visi = METHOD_VISI_PROTECTED;
2254 break;
2255 default:
2256 visi = METHOD_VISI_PUBLIC;
2257 break;
2258 }
2259 }
2260
2261 attriv = rb_intern_str(rb_sprintf("@%"PRIsVALUE, rb_id2str(id)));
2262 if (read) {
2263 rb_add_method(klass, id, VM_METHOD_TYPE_IVAR, (void *)attriv, visi);
2264 }
2265 if (write) {
2266 rb_add_method(klass, rb_id_attrset(id), VM_METHOD_TYPE_ATTRSET, (void *)attriv, visi);
2267 }
2268}
2269
2270void
2272{
2273 const rb_method_entry_t *me;
2274
2275 if (NIL_P(klass)) {
2276 rb_raise(rb_eTypeError, "no class to undef method");
2277 }
2278 rb_class_modify_check(klass);
2279 if (id == object_id || id == id__id__ || id == id__send__ || id == idInitialize) {
2280 rb_warn("undefining '%s' may cause serious problems", rb_id2name(id));
2281 }
2282
2283 me = search_method(klass, id, 0);
2284 if (me && me->def->type == VM_METHOD_TYPE_REFINED) {
2285 me = rb_resolve_refined_method(Qnil, me);
2286 }
2287
2288 if (UNDEFINED_METHOD_ENTRY_P(me) ||
2289 UNDEFINED_REFINED_METHOD_P(me->def)) {
2290 rb_method_name_error(klass, rb_id2str(id));
2291 }
2292
2293 rb_add_method(klass, id, VM_METHOD_TYPE_UNDEF, 0, METHOD_VISI_PUBLIC);
2294
2295 CALL_METHOD_HOOK(klass, undefined, id);
2296}
2297
2298/*
2299 * call-seq:
2300 * undef_method(symbol) -> self
2301 * undef_method(string) -> self
2302 *
2303 * Prevents the current class from responding to calls to the named
2304 * method. Contrast this with <code>remove_method</code>, which deletes
2305 * the method from the particular class; Ruby will still search
2306 * superclasses and mixed-in modules for a possible receiver.
2307 * String arguments are converted to symbols.
2308 *
2309 * class Parent
2310 * def hello
2311 * puts "In parent"
2312 * end
2313 * end
2314 * class Child < Parent
2315 * def hello
2316 * puts "In child"
2317 * end
2318 * end
2319 *
2320 *
2321 * c = Child.new
2322 * c.hello
2323 *
2324 *
2325 * class Child
2326 * remove_method :hello # remove from child, still in parent
2327 * end
2328 * c.hello
2329 *
2330 *
2331 * class Child
2332 * undef_method :hello # prevent any calls to 'hello'
2333 * end
2334 * c.hello
2335 *
2336 * <em>produces:</em>
2337 *
2338 * In child
2339 * In parent
2340 * prog.rb:23: undefined method 'hello' for #<Child:0x401b3bb4> (NoMethodError)
2341 */
2342
2343static VALUE
2344rb_mod_undef_method(int argc, VALUE *argv, VALUE mod)
2345{
2346 int i;
2347 for (i = 0; i < argc; i++) {
2348 VALUE v = argv[i];
2349 ID id = rb_check_id(&v);
2350 if (!id) {
2351 rb_method_name_error(mod, v);
2352 }
2353 rb_undef(mod, id);
2354 }
2355 return mod;
2356}
2357
2358static rb_method_visibility_t
2359check_definition_visibility(VALUE mod, int argc, VALUE *argv)
2360{
2361 const rb_method_entry_t *me;
2362 VALUE mid, include_super, lookup_mod = mod;
2363 int inc_super;
2364 ID id;
2365
2366 rb_scan_args(argc, argv, "11", &mid, &include_super);
2367 id = rb_check_id(&mid);
2368 if (!id) return METHOD_VISI_UNDEF;
2369
2370 if (argc == 1) {
2371 inc_super = 1;
2372 }
2373 else {
2374 inc_super = RTEST(include_super);
2375 if (!inc_super) {
2376 lookup_mod = RCLASS_ORIGIN(mod);
2377 }
2378 }
2379
2380 me = rb_method_entry_without_refinements(lookup_mod, id, NULL);
2381 if (me) {
2382 if (me->def->type == VM_METHOD_TYPE_NOTIMPLEMENTED) return METHOD_VISI_UNDEF;
2383 if (!inc_super && me->owner != mod) return METHOD_VISI_UNDEF;
2384 return METHOD_ENTRY_VISI(me);
2385 }
2386 return METHOD_VISI_UNDEF;
2387}
2388
2389/*
2390 * call-seq:
2391 * mod.method_defined?(symbol, inherit=true) -> true or false
2392 * mod.method_defined?(string, inherit=true) -> true or false
2393 *
2394 * Returns +true+ if the named method is defined by
2395 * _mod_. If _inherit_ is set, the lookup will also search _mod_'s
2396 * ancestors. Public and protected methods are matched.
2397 * String arguments are converted to symbols.
2398 *
2399 * module A
2400 * def method1() end
2401 * def protected_method1() end
2402 * protected :protected_method1
2403 * end
2404 * class B
2405 * def method2() end
2406 * def private_method2() end
2407 * private :private_method2
2408 * end
2409 * class C < B
2410 * include A
2411 * def method3() end
2412 * end
2413 *
2414 * A.method_defined? :method1 #=> true
2415 * C.method_defined? "method1" #=> true
2416 * C.method_defined? "method2" #=> true
2417 * C.method_defined? "method2", true #=> true
2418 * C.method_defined? "method2", false #=> false
2419 * C.method_defined? "method3" #=> true
2420 * C.method_defined? "protected_method1" #=> true
2421 * C.method_defined? "method4" #=> false
2422 * C.method_defined? "private_method2" #=> false
2423 */
2424
2425static VALUE
2426rb_mod_method_defined(int argc, VALUE *argv, VALUE mod)
2427{
2428 rb_method_visibility_t visi = check_definition_visibility(mod, argc, argv);
2429 return RBOOL(visi == METHOD_VISI_PUBLIC || visi == METHOD_VISI_PROTECTED);
2430}
2431
2432static VALUE
2433check_definition(VALUE mod, int argc, VALUE *argv, rb_method_visibility_t visi)
2434{
2435 return RBOOL(check_definition_visibility(mod, argc, argv) == visi);
2436}
2437
2438/*
2439 * call-seq:
2440 * mod.public_method_defined?(symbol, inherit=true) -> true or false
2441 * mod.public_method_defined?(string, inherit=true) -> true or false
2442 *
2443 * Returns +true+ if the named public method is defined by
2444 * _mod_. If _inherit_ is set, the lookup will also search _mod_'s
2445 * ancestors.
2446 * String arguments are converted to symbols.
2447 *
2448 * module A
2449 * def method1() end
2450 * end
2451 * class B
2452 * protected
2453 * def method2() end
2454 * end
2455 * class C < B
2456 * include A
2457 * def method3() end
2458 * end
2459 *
2460 * A.method_defined? :method1 #=> true
2461 * C.public_method_defined? "method1" #=> true
2462 * C.public_method_defined? "method1", true #=> true
2463 * C.public_method_defined? "method1", false #=> true
2464 * C.public_method_defined? "method2" #=> false
2465 * C.method_defined? "method2" #=> true
2466 */
2467
2468static VALUE
2469rb_mod_public_method_defined(int argc, VALUE *argv, VALUE mod)
2470{
2471 return check_definition(mod, argc, argv, METHOD_VISI_PUBLIC);
2472}
2473
2474/*
2475 * call-seq:
2476 * mod.private_method_defined?(symbol, inherit=true) -> true or false
2477 * mod.private_method_defined?(string, inherit=true) -> true or false
2478 *
2479 * Returns +true+ if the named private method is defined by
2480 * _mod_. If _inherit_ is set, the lookup will also search _mod_'s
2481 * ancestors.
2482 * String arguments are converted to symbols.
2483 *
2484 * module A
2485 * def method1() end
2486 * end
2487 * class B
2488 * private
2489 * def method2() end
2490 * end
2491 * class C < B
2492 * include A
2493 * def method3() end
2494 * end
2495 *
2496 * A.method_defined? :method1 #=> true
2497 * C.private_method_defined? "method1" #=> false
2498 * C.private_method_defined? "method2" #=> true
2499 * C.private_method_defined? "method2", true #=> true
2500 * C.private_method_defined? "method2", false #=> false
2501 * C.method_defined? "method2" #=> false
2502 */
2503
2504static VALUE
2505rb_mod_private_method_defined(int argc, VALUE *argv, VALUE mod)
2506{
2507 return check_definition(mod, argc, argv, METHOD_VISI_PRIVATE);
2508}
2509
2510/*
2511 * call-seq:
2512 * mod.protected_method_defined?(symbol, inherit=true) -> true or false
2513 * mod.protected_method_defined?(string, inherit=true) -> true or false
2514 *
2515 * Returns +true+ if the named protected method is defined
2516 * _mod_. If _inherit_ is set, the lookup will also search _mod_'s
2517 * ancestors.
2518 * String arguments are converted to symbols.
2519 *
2520 * module A
2521 * def method1() end
2522 * end
2523 * class B
2524 * protected
2525 * def method2() end
2526 * end
2527 * class C < B
2528 * include A
2529 * def method3() end
2530 * end
2531 *
2532 * A.method_defined? :method1 #=> true
2533 * C.protected_method_defined? "method1" #=> false
2534 * C.protected_method_defined? "method2" #=> true
2535 * C.protected_method_defined? "method2", true #=> true
2536 * C.protected_method_defined? "method2", false #=> false
2537 * C.method_defined? "method2" #=> true
2538 */
2539
2540static VALUE
2541rb_mod_protected_method_defined(int argc, VALUE *argv, VALUE mod)
2542{
2543 return check_definition(mod, argc, argv, METHOD_VISI_PROTECTED);
2544}
2545
2546int
2547rb_method_entry_eq(const rb_method_entry_t *m1, const rb_method_entry_t *m2)
2548{
2549 return rb_method_definition_eq(m1->def, m2->def);
2550}
2551
2552static const rb_method_definition_t *
2553original_method_definition(const rb_method_definition_t *def)
2554{
2555 again:
2556 if (def) {
2557 switch (def->type) {
2558 case VM_METHOD_TYPE_REFINED:
2559 if (def->body.refined.orig_me) {
2560 def = def->body.refined.orig_me->def;
2561 goto again;
2562 }
2563 break;
2564 case VM_METHOD_TYPE_ALIAS:
2565 def = def->body.alias.original_me->def;
2566 goto again;
2567 default:
2568 break;
2569 }
2570 }
2571 return def;
2572}
2573
2574int
2575rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2)
2576{
2577 d1 = original_method_definition(d1);
2578 d2 = original_method_definition(d2);
2579
2580 if (d1 == d2) return 1;
2581 if (!d1 || !d2) return 0;
2582 if (d1->type != d2->type) return 0;
2583
2584 switch (d1->type) {
2585 case VM_METHOD_TYPE_ISEQ:
2586 return d1->body.iseq.iseqptr == d2->body.iseq.iseqptr;
2587 case VM_METHOD_TYPE_CFUNC:
2588 return
2589 d1->body.cfunc.func == d2->body.cfunc.func &&
2590 d1->body.cfunc.argc == d2->body.cfunc.argc;
2591 case VM_METHOD_TYPE_ATTRSET:
2592 case VM_METHOD_TYPE_IVAR:
2593 return d1->body.attr.id == d2->body.attr.id;
2594 case VM_METHOD_TYPE_BMETHOD:
2595 return RTEST(rb_equal(d1->body.bmethod.proc, d2->body.bmethod.proc));
2596 case VM_METHOD_TYPE_MISSING:
2597 return d1->original_id == d2->original_id;
2598 case VM_METHOD_TYPE_ZSUPER:
2599 case VM_METHOD_TYPE_NOTIMPLEMENTED:
2600 case VM_METHOD_TYPE_UNDEF:
2601 return 1;
2602 case VM_METHOD_TYPE_OPTIMIZED:
2603 return (d1->body.optimized.type == d2->body.optimized.type) &&
2604 (d1->body.optimized.index == d2->body.optimized.index);
2605 case VM_METHOD_TYPE_REFINED:
2606 case VM_METHOD_TYPE_ALIAS:
2607 break;
2608 }
2609 rb_bug("rb_method_definition_eq: unsupported type: %d", d1->type);
2610}
2611
2612static st_index_t
2613rb_hash_method_definition(st_index_t hash, const rb_method_definition_t *def)
2614{
2615 hash = rb_hash_uint(hash, def->type);
2616 def = original_method_definition(def);
2617
2618 if (!def) return hash;
2619
2620 switch (def->type) {
2621 case VM_METHOD_TYPE_ISEQ:
2622 return rb_hash_uint(hash, (st_index_t)def->body.iseq.iseqptr->body);
2623 case VM_METHOD_TYPE_CFUNC:
2624 hash = rb_hash_uint(hash, (st_index_t)def->body.cfunc.func);
2625 return rb_hash_uint(hash, def->body.cfunc.argc);
2626 case VM_METHOD_TYPE_ATTRSET:
2627 case VM_METHOD_TYPE_IVAR:
2628 return rb_hash_uint(hash, def->body.attr.id);
2629 case VM_METHOD_TYPE_BMETHOD:
2630 return rb_hash_proc(hash, def->body.bmethod.proc);
2631 case VM_METHOD_TYPE_MISSING:
2632 return rb_hash_uint(hash, def->original_id);
2633 case VM_METHOD_TYPE_ZSUPER:
2634 case VM_METHOD_TYPE_NOTIMPLEMENTED:
2635 case VM_METHOD_TYPE_UNDEF:
2636 return hash;
2637 case VM_METHOD_TYPE_OPTIMIZED:
2638 hash = rb_hash_uint(hash, def->body.optimized.index);
2639 return rb_hash_uint(hash, def->body.optimized.type);
2640 case VM_METHOD_TYPE_REFINED:
2641 case VM_METHOD_TYPE_ALIAS:
2642 break; /* unreachable */
2643 }
2644 rb_bug("rb_hash_method_definition: unsupported method type (%d)", def->type);
2645}
2646
2647st_index_t
2648rb_hash_method_entry(st_index_t hash, const rb_method_entry_t *me)
2649{
2650 return rb_hash_method_definition(hash, me->def);
2651}
2652
2653void
2654rb_alias(VALUE klass, ID alias_name, ID original_name)
2655{
2656 const VALUE target_klass = klass;
2657 VALUE defined_class;
2658 const rb_method_entry_t *orig_me;
2659 rb_method_visibility_t visi = METHOD_VISI_UNDEF;
2660
2661 if (NIL_P(klass)) {
2662 rb_raise(rb_eTypeError, "no class to make alias");
2663 }
2664
2665 rb_class_modify_check(klass);
2666
2667 again:
2668 orig_me = search_method(klass, original_name, &defined_class);
2669
2670 if (orig_me && orig_me->def->type == VM_METHOD_TYPE_REFINED) {
2671 orig_me = rb_resolve_refined_method(Qnil, orig_me);
2672 }
2673
2674 if (UNDEFINED_METHOD_ENTRY_P(orig_me) ||
2675 UNDEFINED_REFINED_METHOD_P(orig_me->def)) {
2676 if ((!RB_TYPE_P(klass, T_MODULE)) ||
2677 (orig_me = search_method(rb_cObject, original_name, &defined_class),
2678 UNDEFINED_METHOD_ENTRY_P(orig_me))) {
2679 rb_print_undef(target_klass, original_name, METHOD_VISI_UNDEF);
2680 }
2681 }
2682
2683 switch (orig_me->def->type) {
2684 case VM_METHOD_TYPE_ZSUPER:
2685 klass = RCLASS_SUPER(klass);
2686 original_name = orig_me->def->original_id;
2687 visi = METHOD_ENTRY_VISI(orig_me);
2688 goto again;
2689 case VM_METHOD_TYPE_ALIAS:
2690 visi = METHOD_ENTRY_VISI(orig_me);
2691 orig_me = orig_me->def->body.alias.original_me;
2692 VM_ASSERT(orig_me->def->type != VM_METHOD_TYPE_ALIAS);
2693 break;
2694 default: break;
2695 }
2696
2697 if (visi == METHOD_VISI_UNDEF) visi = METHOD_ENTRY_VISI(orig_me);
2698
2699 if (orig_me->defined_class == 0) {
2700 rb_method_entry_make(target_klass, alias_name, target_klass, visi,
2701 VM_METHOD_TYPE_ALIAS, NULL, orig_me->called_id,
2702 (void *)rb_method_entry_clone(orig_me));
2703 method_added(target_klass, alias_name);
2704 }
2705 else {
2706 rb_method_entry_t *alias_me;
2707
2708 alias_me = method_entry_set(target_klass, alias_name, orig_me, visi, orig_me->owner);
2709 RB_OBJ_WRITE(alias_me, &alias_me->owner, target_klass);
2710
2711 if (RB_TYPE_P(target_klass, T_MODULE)) {
2712 // defined_class should not be set
2713 }
2714 else {
2715 RB_OBJ_WRITE(alias_me, &alias_me->defined_class, orig_me->defined_class);
2716 }
2717 }
2718}
2719
2720/*
2721 * call-seq:
2722 * alias_method(new_name, old_name) -> symbol
2723 *
2724 * Makes <i>new_name</i> a new copy of the method <i>old_name</i>. This can
2725 * be used to retain access to methods that are overridden.
2726 *
2727 * module Mod
2728 * alias_method :orig_exit, :exit #=> :orig_exit
2729 * def exit(code=0)
2730 * puts "Exiting with code #{code}"
2731 * orig_exit(code)
2732 * end
2733 * end
2734 * include Mod
2735 * exit(99)
2736 *
2737 * <em>produces:</em>
2738 *
2739 * Exiting with code 99
2740 */
2741
2742static VALUE
2743rb_mod_alias_method(VALUE mod, VALUE newname, VALUE oldname)
2744{
2745 ID oldid = rb_check_id(&oldname);
2746 if (!oldid) {
2747 rb_print_undef_str(mod, oldname);
2748 }
2749 VALUE id = rb_to_id(newname);
2750 rb_alias(mod, id, oldid);
2751 return ID2SYM(id);
2752}
2753
2754static void
2755check_and_export_method(VALUE self, VALUE name, rb_method_visibility_t visi)
2756{
2757 ID id = rb_check_id(&name);
2758 if (!id) {
2759 rb_print_undef_str(self, name);
2760 }
2761 rb_export_method(self, id, visi);
2762}
2763
2764static void
2765set_method_visibility(VALUE self, int argc, const VALUE *argv, rb_method_visibility_t visi)
2766{
2767 int i;
2768
2769 rb_check_frozen(self);
2770 if (argc == 0) {
2771 rb_warning("%"PRIsVALUE" with no argument is just ignored",
2772 QUOTE_ID(rb_frame_callee()));
2773 return;
2774 }
2775
2776
2777 VALUE v;
2778
2779 if (argc == 1 && (v = rb_check_array_type(argv[0])) != Qnil) {
2780 long j;
2781
2782 for (j = 0; j < RARRAY_LEN(v); j++) {
2783 check_and_export_method(self, RARRAY_AREF(v, j), visi);
2784 }
2785 }
2786 else {
2787 for (i = 0; i < argc; i++) {
2788 check_and_export_method(self, argv[i], visi);
2789 }
2790 }
2791}
2792
2793static VALUE
2794set_visibility(int argc, const VALUE *argv, VALUE module, rb_method_visibility_t visi)
2795{
2796 if (argc == 0) {
2797 scope_visibility_check();
2798 rb_scope_visibility_set(visi);
2799 return Qnil;
2800 }
2801
2802 set_method_visibility(module, argc, argv, visi);
2803 if (argc == 1) {
2804 return argv[0];
2805 }
2806 return rb_ary_new_from_values(argc, argv);
2807}
2808
2809/*
2810 * call-seq:
2811 * public -> nil
2812 * public(method_name) -> method_name
2813 * public(method_name, method_name, ...) -> array
2814 * public(array) -> array
2815 *
2816 * With no arguments, sets the default visibility for subsequently
2817 * defined methods to public. With arguments, sets the named methods to
2818 * have public visibility.
2819 * String arguments are converted to symbols.
2820 * An Array of Symbols and/or Strings is also accepted.
2821 * If a single argument is passed, it is returned.
2822 * If no argument is passed, nil is returned.
2823 * If multiple arguments are passed, the arguments are returned as an array.
2824 */
2825
2826static VALUE
2827rb_mod_public(int argc, VALUE *argv, VALUE module)
2828{
2829 return set_visibility(argc, argv, module, METHOD_VISI_PUBLIC);
2830}
2831
2832/*
2833 * call-seq:
2834 * protected -> nil
2835 * protected(method_name) -> method_name
2836 * protected(method_name, method_name, ...) -> array
2837 * protected(array) -> array
2838 *
2839 * Sets the visibility of a section or of a list of method names as protected.
2840 * Accepts no arguments, a splat of method names (symbols or strings) or an
2841 * array of method names. Returns the arguments that it received.
2842 *
2843 * == Important difference between protected in other languages
2844 *
2845 * Protected methods in Ruby are different from other languages such as Java,
2846 * where methods are marked as protected to give access to subclasses. In Ruby,
2847 * subclasses <b>already have access to all methods defined in the parent
2848 * class</b>, even private ones.
2849 *
2850 * Marking a method as protected allows <b>different objects of the same
2851 * class</b> to call it.
2852 *
2853 * One use case is for comparison methods, such as <code>==</code>, if we want
2854 * to expose a method for comparison between objects of the same class without
2855 * making the method public to objects of other classes.
2856 *
2857 * == Performance considerations
2858 *
2859 * Protected methods are slower than others because they can't use inline
2860 * cache.
2861 *
2862 * == Example
2863 *
2864 * class Account
2865 * # Mark balance as protected, so that we can compare between accounts
2866 * # without making it public.
2867 * attr_reader :balance
2868 * protected :balance
2869 *
2870 * def initialize(balance)
2871 * @balance = balance
2872 * end
2873 *
2874 * def >(other)
2875 * # The invocation to `other.balance` is allowed because `other` is a
2876 * # different object of the same class (Account).
2877 * balance > other.balance
2878 * end
2879 * end
2880 *
2881 * account1 = Account.new(100)
2882 * account2 = Account.new(50)
2883 *
2884 * account1 > account2 # => true (works)
2885 * account1.balance # => NoMethodError (fails because balance is not public)
2886 *
2887 * To show a private method on RDoc, use <code>:doc:</code> instead of this.
2888 */
2889
2890static VALUE
2891rb_mod_protected(int argc, VALUE *argv, VALUE module)
2892{
2893 return set_visibility(argc, argv, module, METHOD_VISI_PROTECTED);
2894}
2895
2896/*
2897 * call-seq:
2898 * private -> nil
2899 * private(method_name) -> method_name
2900 * private(method_name, method_name, ...) -> array
2901 * private(array) -> array
2902 *
2903 * With no arguments, sets the default visibility for subsequently
2904 * defined methods to private. With arguments, sets the named methods
2905 * to have private visibility.
2906 * String arguments are converted to symbols.
2907 * An Array of Symbols and/or Strings is also accepted.
2908 * If a single argument is passed, it is returned.
2909 * If no argument is passed, nil is returned.
2910 * If multiple arguments are passed, the arguments are returned as an array.
2911 *
2912 * module Mod
2913 * def a() end
2914 * def b() end
2915 * private
2916 * def c() end
2917 * private :a
2918 * end
2919 * Mod.private_instance_methods #=> [:a, :c]
2920 *
2921 * Note that to show a private method on RDoc, use <code>:doc:</code>.
2922 */
2923
2924static VALUE
2925rb_mod_private(int argc, VALUE *argv, VALUE module)
2926{
2927 return set_visibility(argc, argv, module, METHOD_VISI_PRIVATE);
2928}
2929
2930/*
2931 * call-seq:
2932 * ruby2_keywords(method_name, ...) -> nil
2933 *
2934 * For the given method names, marks the method as passing keywords through
2935 * a normal argument splat. This should only be called on methods that
2936 * accept an argument splat (<tt>*args</tt>) but not explicit keywords or
2937 * a keyword splat. It marks the method such that if the method is called
2938 * with keyword arguments, the final hash argument is marked with a special
2939 * flag such that if it is the final element of a normal argument splat to
2940 * another method call, and that method call does not include explicit
2941 * keywords or a keyword splat, the final element is interpreted as keywords.
2942 * In other words, keywords will be passed through the method to other
2943 * methods.
2944 *
2945 * This should only be used for methods that delegate keywords to another
2946 * method, and only for backwards compatibility with Ruby versions before 3.0.
2947 * See https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
2948 * for details on why +ruby2_keywords+ exists and when and how to use it.
2949 *
2950 * This method will probably be removed at some point, as it exists only
2951 * for backwards compatibility. As it does not exist in Ruby versions before
2952 * 2.7, check that the module responds to this method before calling it:
2953 *
2954 * module Mod
2955 * def foo(meth, *args, &block)
2956 * send(:"do_#{meth}", *args, &block)
2957 * end
2958 * ruby2_keywords(:foo) if respond_to?(:ruby2_keywords, true)
2959 * end
2960 *
2961 * However, be aware that if the +ruby2_keywords+ method is removed, the
2962 * behavior of the +foo+ method using the above approach will change so that
2963 * the method does not pass through keywords.
2964 */
2965
2966static VALUE
2967rb_mod_ruby2_keywords(int argc, VALUE *argv, VALUE module)
2968{
2969 int i;
2970 VALUE origin_class = RCLASS_ORIGIN(module);
2971
2973 rb_check_frozen(module);
2974
2975 for (i = 0; i < argc; i++) {
2976 VALUE v = argv[i];
2977 ID name = rb_check_id(&v);
2979 VALUE defined_class;
2980
2981 if (!name) {
2982 rb_print_undef_str(module, v);
2983 }
2984
2985 me = search_method(origin_class, name, &defined_class);
2986 if (!me && RB_TYPE_P(module, T_MODULE)) {
2987 me = search_method(rb_cObject, name, &defined_class);
2988 }
2989
2990 if (UNDEFINED_METHOD_ENTRY_P(me) ||
2991 UNDEFINED_REFINED_METHOD_P(me->def)) {
2992 rb_print_undef(module, name, METHOD_VISI_UNDEF);
2993 }
2994
2995 if (module == defined_class || origin_class == defined_class) {
2996 switch (me->def->type) {
2997 case VM_METHOD_TYPE_ISEQ:
2998 if (ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.has_rest &&
2999 !ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.has_post &&
3000 !ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.has_kw &&
3001 !ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.has_kwrest) {
3002 ISEQ_BODY(me->def->body.iseq.iseqptr)->param.flags.ruby2_keywords = 1;
3003 rb_clear_method_cache(module, name);
3004 }
3005 else {
3006 rb_warn("Skipping set of ruby2_keywords flag for %"PRIsVALUE" (method accepts keywords or post arguments or method does not accept argument splat)", QUOTE_ID(name));
3007 }
3008 break;
3009 case VM_METHOD_TYPE_BMETHOD: {
3010 VALUE procval = me->def->body.bmethod.proc;
3011 if (vm_block_handler_type(procval) == block_handler_type_proc) {
3012 procval = vm_proc_to_block_handler(VM_BH_TO_PROC(procval));
3013 }
3014
3015 if (vm_block_handler_type(procval) == block_handler_type_iseq) {
3016 const struct rb_captured_block *captured = VM_BH_TO_ISEQ_BLOCK(procval);
3017 const rb_iseq_t *iseq = rb_iseq_check(captured->code.iseq);
3018 if (ISEQ_BODY(iseq)->param.flags.has_rest &&
3019 !ISEQ_BODY(iseq)->param.flags.has_post &&
3020 !ISEQ_BODY(iseq)->param.flags.has_kw &&
3021 !ISEQ_BODY(iseq)->param.flags.has_kwrest) {
3022 ISEQ_BODY(iseq)->param.flags.ruby2_keywords = 1;
3023 rb_clear_method_cache(module, name);
3024 }
3025 else {
3026 rb_warn("Skipping set of ruby2_keywords flag for %"PRIsVALUE" (method accepts keywords or post arguments or method does not accept argument splat)", QUOTE_ID(name));
3027 }
3028 break;
3029 }
3030 }
3031 /* fallthrough */
3032 default:
3033 rb_warn("Skipping set of ruby2_keywords flag for %"PRIsVALUE" (method not defined in Ruby)", QUOTE_ID(name));
3034 break;
3035 }
3036 }
3037 else {
3038 rb_warn("Skipping set of ruby2_keywords flag for %"PRIsVALUE" (can only set in method defining module)", QUOTE_ID(name));
3039 }
3040 }
3041 return Qnil;
3042}
3043
3044/*
3045 * call-seq:
3046 * mod.public_class_method(symbol, ...) -> mod
3047 * mod.public_class_method(string, ...) -> mod
3048 * mod.public_class_method(array) -> mod
3049 *
3050 * Makes a list of existing class methods public.
3051 *
3052 * String arguments are converted to symbols.
3053 * An Array of Symbols and/or Strings is also accepted.
3054 */
3055
3056static VALUE
3057rb_mod_public_method(int argc, VALUE *argv, VALUE obj)
3058{
3059 set_method_visibility(rb_singleton_class(obj), argc, argv, METHOD_VISI_PUBLIC);
3060 return obj;
3061}
3062
3063/*
3064 * call-seq:
3065 * mod.private_class_method(symbol, ...) -> mod
3066 * mod.private_class_method(string, ...) -> mod
3067 * mod.private_class_method(array) -> mod
3068 *
3069 * Makes existing class methods private. Often used to hide the default
3070 * constructor <code>new</code>.
3071 *
3072 * String arguments are converted to symbols.
3073 * An Array of Symbols and/or Strings is also accepted.
3074 *
3075 * class SimpleSingleton # Not thread safe
3076 * private_class_method :new
3077 * def SimpleSingleton.create(*args, &block)
3078 * @me = new(*args, &block) if ! @me
3079 * @me
3080 * end
3081 * end
3082 */
3083
3084static VALUE
3085rb_mod_private_method(int argc, VALUE *argv, VALUE obj)
3086{
3087 set_method_visibility(rb_singleton_class(obj), argc, argv, METHOD_VISI_PRIVATE);
3088 return obj;
3089}
3090
3091/*
3092 * call-seq:
3093 * public
3094 * public(symbol, ...)
3095 * public(string, ...)
3096 * public(array)
3097 *
3098 * With no arguments, sets the default visibility for subsequently
3099 * defined methods to public. With arguments, sets the named methods to
3100 * have public visibility.
3101 *
3102 * String arguments are converted to symbols.
3103 * An Array of Symbols and/or Strings is also accepted.
3104 */
3105
3106static VALUE
3107top_public(int argc, VALUE *argv, VALUE _)
3108{
3109 return rb_mod_public(argc, argv, rb_top_main_class("public"));
3110}
3111
3112/*
3113 * call-seq:
3114 * private
3115 * private(symbol, ...)
3116 * private(string, ...)
3117 * private(array)
3118 *
3119 * With no arguments, sets the default visibility for subsequently
3120 * defined methods to private. With arguments, sets the named methods to
3121 * have private visibility.
3122 *
3123 * String arguments are converted to symbols.
3124 * An Array of Symbols and/or Strings is also accepted.
3125 */
3126static VALUE
3127top_private(int argc, VALUE *argv, VALUE _)
3128{
3129 return rb_mod_private(argc, argv, rb_top_main_class("private"));
3130}
3131
3132/*
3133 * call-seq:
3134 * ruby2_keywords(method_name, ...) -> self
3135 *
3136 * For the given method names, marks the method as passing keywords through
3137 * a normal argument splat. See Module#ruby2_keywords in detail.
3138 */
3139static VALUE
3140top_ruby2_keywords(int argc, VALUE *argv, VALUE module)
3141{
3142 return rb_mod_ruby2_keywords(argc, argv, rb_top_main_class("ruby2_keywords"));
3143}
3144
3145/*
3146 * call-seq:
3147 * module_function -> nil
3148 * module_function(method_name) -> method_name
3149 * module_function(method_name, method_name, ...) -> array
3150 *
3151 * Creates module functions for the named methods. These functions may
3152 * be called with the module as a receiver, and also become available
3153 * as instance methods to classes that mix in the module. Module
3154 * functions are copies of the original, and so may be changed
3155 * independently. The instance-method versions are made private. If
3156 * used with no arguments, subsequently defined methods become module
3157 * functions.
3158 * String arguments are converted to symbols.
3159 * If a single argument is passed, it is returned.
3160 * If no argument is passed, nil is returned.
3161 * If multiple arguments are passed, the arguments are returned as an array.
3162 *
3163 * module Mod
3164 * def one
3165 * "This is one"
3166 * end
3167 * module_function :one
3168 * end
3169 * class Cls
3170 * include Mod
3171 * def call_one
3172 * one
3173 * end
3174 * end
3175 * Mod.one #=> "This is one"
3176 * c = Cls.new
3177 * c.call_one #=> "This is one"
3178 * module Mod
3179 * def one
3180 * "This is the new one"
3181 * end
3182 * end
3183 * Mod.one #=> "This is one"
3184 * c.call_one #=> "This is the new one"
3185 */
3186
3187static VALUE
3188rb_mod_modfunc(int argc, VALUE *argv, VALUE module)
3189{
3190 int i;
3191 ID id;
3192 const rb_method_entry_t *me;
3193
3194 if (!RB_TYPE_P(module, T_MODULE)) {
3195 rb_raise(rb_eTypeError, "module_function must be called for modules");
3196 }
3197
3198 if (argc == 0) {
3199 rb_scope_module_func_set();
3200 return Qnil;
3201 }
3202
3203 set_method_visibility(module, argc, argv, METHOD_VISI_PRIVATE);
3204
3205 for (i = 0; i < argc; i++) {
3206 VALUE m = module;
3207
3208 id = rb_to_id(argv[i]);
3209 for (;;) {
3210 me = search_method(m, id, 0);
3211 if (me == 0) {
3212 me = search_method(rb_cObject, id, 0);
3213 }
3214 if (UNDEFINED_METHOD_ENTRY_P(me)) {
3215 rb_print_undef(module, id, METHOD_VISI_UNDEF);
3216 }
3217 if (me->def->type != VM_METHOD_TYPE_ZSUPER) {
3218 break; /* normal case: need not to follow 'super' link */
3219 }
3220 m = RCLASS_SUPER(m);
3221 if (!m)
3222 break;
3223 }
3224 rb_method_entry_set(rb_singleton_class(module), id, me, METHOD_VISI_PUBLIC);
3225 }
3226 if (argc == 1) {
3227 return argv[0];
3228 }
3229 return rb_ary_new_from_values(argc, argv);
3230}
3231
3232#ifdef __GNUC__
3233#pragma push_macro("rb_method_basic_definition_p")
3234#undef rb_method_basic_definition_p
3235#endif
3236int
3237rb_method_basic_definition_p(VALUE klass, ID id)
3238{
3239 const rb_callable_method_entry_t *cme;
3240 if (!klass) return TRUE; /* hidden object cannot be overridden */
3241 cme = rb_callable_method_entry(klass, id);
3242 return (cme && METHOD_ENTRY_BASIC(cme)) ? TRUE : FALSE;
3243}
3244#ifdef __GNUC__
3245#pragma pop_macro("rb_method_basic_definition_p")
3246#endif
3247
3248static VALUE
3249call_method_entry(rb_execution_context_t *ec, VALUE defined_class, VALUE obj, ID id,
3250 const rb_callable_method_entry_t *cme, int argc, const VALUE *argv, int kw_splat)
3251{
3252 VALUE passed_block_handler = vm_passed_block_handler(ec);
3253 VALUE result = rb_vm_call_kw(ec, obj, id, argc, argv, cme, kw_splat);
3254 vm_passed_block_handler_set(ec, passed_block_handler);
3255 return result;
3256}
3257
3258static VALUE
3259basic_obj_respond_to_missing(rb_execution_context_t *ec, VALUE klass, VALUE obj,
3260 VALUE mid, VALUE priv)
3261{
3262 VALUE defined_class, args[2];
3263 const ID rtmid = idRespond_to_missing;
3264 const rb_callable_method_entry_t *const cme = callable_method_entry(klass, rtmid, &defined_class);
3265
3266 if (!cme || METHOD_ENTRY_BASIC(cme)) return Qundef;
3267 args[0] = mid;
3268 args[1] = priv;
3269 return call_method_entry(ec, defined_class, obj, rtmid, cme, 2, args, RB_NO_KEYWORDS);
3270}
3271
3272static inline int
3273basic_obj_respond_to(rb_execution_context_t *ec, VALUE obj, ID id, int pub)
3274{
3275 VALUE klass = CLASS_OF(obj);
3276 VALUE ret;
3277
3278 switch (method_boundp(klass, id, pub|BOUND_RESPONDS)) {
3279 case 2:
3280 return FALSE;
3281 case 0:
3282 ret = basic_obj_respond_to_missing(ec, klass, obj, ID2SYM(id),
3283 RBOOL(!pub));
3284 return RTEST(ret) && !UNDEF_P(ret);
3285 default:
3286 return TRUE;
3287 }
3288}
3289
3290static int
3291vm_respond_to(rb_execution_context_t *ec, VALUE klass, VALUE obj, ID id, int priv)
3292{
3293 VALUE defined_class;
3294 const ID resid = idRespond_to;
3295 const rb_callable_method_entry_t *const cme = callable_method_entry(klass, resid, &defined_class);
3296
3297 if (!cme) return -1;
3298 if (METHOD_ENTRY_BASIC(cme)) {
3299 return -1;
3300 }
3301 else {
3302 int argc = 1;
3303 VALUE args[2];
3304 VALUE result;
3305
3306 args[0] = ID2SYM(id);
3307 args[1] = Qtrue;
3308 if (priv) {
3309 argc = rb_method_entry_arity((const rb_method_entry_t *)cme);
3310 if (argc > 2) {
3311 rb_raise(rb_eArgError,
3312 "respond_to? must accept 1 or 2 arguments (requires %d)",
3313 argc);
3314 }
3315 if (argc != 1) {
3316 argc = 2;
3317 }
3318 else if (!NIL_P(ruby_verbose)) {
3319 VALUE location = rb_method_entry_location((const rb_method_entry_t *)cme);
3321 "%"PRIsVALUE"%c""respond_to?(:%"PRIsVALUE") uses"
3322 " the deprecated method signature, which takes one parameter",
3323 (RCLASS_SINGLETON_P(klass) ? obj : klass),
3324 (RCLASS_SINGLETON_P(klass) ? '.' : '#'),
3325 QUOTE_ID(id));
3326 if (!NIL_P(location)) {
3327 VALUE path = RARRAY_AREF(location, 0);
3328 VALUE line = RARRAY_AREF(location, 1);
3329 if (!NIL_P(path)) {
3331 RSTRING_PTR(path), NUM2INT(line),
3332 "respond_to? is defined here");
3333 }
3334 }
3335 }
3336 }
3337 result = call_method_entry(ec, defined_class, obj, resid, cme, argc, args, RB_NO_KEYWORDS);
3338 return RTEST(result);
3339 }
3340}
3341
3342int
3343rb_obj_respond_to(VALUE obj, ID id, int priv)
3344{
3345 rb_execution_context_t *ec = GET_EC();
3346 return rb_ec_obj_respond_to(ec, obj, id, priv);
3347}
3348
3349int
3350rb_ec_obj_respond_to(rb_execution_context_t *ec, VALUE obj, ID id, int priv)
3351{
3352 VALUE klass = CLASS_OF(obj);
3353 int ret = vm_respond_to(ec, klass, obj, id, priv);
3354 if (ret == -1) ret = basic_obj_respond_to(ec, obj, id, !priv);
3355 return ret;
3356}
3357
3358int
3360{
3361 return rb_obj_respond_to(obj, id, FALSE);
3362}
3363
3364
3365/*
3366 * call-seq:
3367 * obj.respond_to?(symbol, include_all=false) -> true or false
3368 * obj.respond_to?(string, include_all=false) -> true or false
3369 *
3370 * Returns +true+ if _obj_ responds to the given method. Private and
3371 * protected methods are included in the search only if the optional
3372 * second parameter evaluates to +true+.
3373 *
3374 * If the method is not implemented,
3375 * as Process.fork on Windows, File.lchmod on GNU/Linux, etc.,
3376 * false is returned.
3377 *
3378 * If the method is not defined, <code>respond_to_missing?</code>
3379 * method is called and the result is returned.
3380 *
3381 * When the method name parameter is given as a string, the string is
3382 * converted to a symbol.
3383 */
3384
3385static VALUE
3386obj_respond_to(int argc, VALUE *argv, VALUE obj)
3387{
3388 VALUE mid, priv;
3389 ID id;
3390 rb_execution_context_t *ec = GET_EC();
3391
3392 rb_scan_args(argc, argv, "11", &mid, &priv);
3393 if (!(id = rb_check_id(&mid))) {
3394 VALUE ret = basic_obj_respond_to_missing(ec, CLASS_OF(obj), obj,
3395 rb_to_symbol(mid), priv);
3396 if (UNDEF_P(ret)) ret = Qfalse;
3397 return ret;
3398 }
3399 return RBOOL(basic_obj_respond_to(ec, obj, id, !RTEST(priv)));
3400}
3401
3402/*
3403 * call-seq:
3404 * obj.respond_to_missing?(symbol, include_all) -> true or false
3405 * obj.respond_to_missing?(string, include_all) -> true or false
3406 *
3407 * DO NOT USE THIS DIRECTLY.
3408 *
3409 * Hook method to return whether the _obj_ can respond to _id_ method
3410 * or not.
3411 *
3412 * When the method name parameter is given as a string, the string is
3413 * converted to a symbol.
3414 *
3415 * See #respond_to?, and the example of BasicObject.
3416 */
3417static VALUE
3418obj_respond_to_missing(VALUE obj, VALUE mid, VALUE priv)
3419{
3420 return Qfalse;
3421}
3422
3423void
3424Init_eval_method(void)
3425{
3426 rb_define_method(rb_mKernel, "respond_to?", obj_respond_to, -1);
3427 rb_define_method(rb_mKernel, "respond_to_missing?", obj_respond_to_missing, 2);
3428
3429 rb_define_method(rb_cModule, "remove_method", rb_mod_remove_method, -1);
3430 rb_define_method(rb_cModule, "undef_method", rb_mod_undef_method, -1);
3431 rb_define_method(rb_cModule, "alias_method", rb_mod_alias_method, 2);
3432 rb_define_private_method(rb_cModule, "public", rb_mod_public, -1);
3433 rb_define_private_method(rb_cModule, "protected", rb_mod_protected, -1);
3434 rb_define_private_method(rb_cModule, "private", rb_mod_private, -1);
3435 rb_define_private_method(rb_cModule, "module_function", rb_mod_modfunc, -1);
3436 rb_define_private_method(rb_cModule, "ruby2_keywords", rb_mod_ruby2_keywords, -1);
3437
3438 rb_define_method(rb_cModule, "method_defined?", rb_mod_method_defined, -1);
3439 rb_define_method(rb_cModule, "public_method_defined?", rb_mod_public_method_defined, -1);
3440 rb_define_method(rb_cModule, "private_method_defined?", rb_mod_private_method_defined, -1);
3441 rb_define_method(rb_cModule, "protected_method_defined?", rb_mod_protected_method_defined, -1);
3442 rb_define_method(rb_cModule, "public_class_method", rb_mod_public_method, -1);
3443 rb_define_method(rb_cModule, "private_class_method", rb_mod_private_method, -1);
3444
3446 "public", top_public, -1);
3448 "private", top_private, -1);
3450 "ruby2_keywords", top_ruby2_keywords, -1);
3451
3452 {
3453#define REPLICATE_METHOD(klass, id) do { \
3454 const rb_method_entry_t *me = rb_method_entry((klass), (id)); \
3455 rb_method_entry_set((klass), (id), me, METHOD_ENTRY_VISI(me)); \
3456 } while (0)
3457
3458 REPLICATE_METHOD(rb_eException, idMethodMissing);
3459 REPLICATE_METHOD(rb_eException, idRespond_to);
3460 REPLICATE_METHOD(rb_eException, idRespond_to_missing);
3461 }
3462}
#define RUBY_ASSERT_ALWAYS(expr,...)
A variant of RUBY_ASSERT that does not interface with RUBY_DEBUG.
Definition assert.h:199
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
Definition atomic.h:69
#define RUBY_ATOMIC_FETCH_ADD(var, val)
Atomically replaces the value pointed by var with the result of addition of val to the old value of v...
Definition atomic.h:118
#define RUBY_ATOMIC_FETCH_SUB(var, val)
Atomically replaces the value pointed by var with the result of subtraction of val to the old value o...
Definition atomic.h:129
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_private_method(klass, mid, func, arity)
Defines klass#mid and makes it private.
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
Definition class.c:2805
void rb_class_modify_check(VALUE klass)
Asserts that klass is not a frozen class.
Definition eval.c:421
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
Retrieves argument from argc and argv to given VALUE references according to the format string.
Definition class.c:3143
#define xfree
Old name of ruby_xfree.
Definition xmalloc.h:58
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
Definition assume.h:29
#define ZALLOC
Old name of RB_ZALLOC.
Definition memory.h:402
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:206
#define T_MODULE
Old name of RUBY_T_MODULE.
Definition value_type.h:70
#define T_ICLASS
Old name of RUBY_T_ICLASS.
Definition value_type.h:66
#define rb_ary_new3
Old name of rb_ary_new_from_args.
Definition array.h:658
#define Qtrue
Old name of RUBY_Qtrue.
#define NUM2INT
Old name of RB_NUM2INT.
Definition int.h:44
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define NIL_P
Old name of RB_NIL_P.
#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
void rb_notimplement(void)
Definition error.c:3839
void rb_category_warn(rb_warning_category_t category, const char *fmt,...)
Identical to rb_category_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:476
#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:1430
void rb_category_compile_warn(rb_warning_category_t category, const char *file, int line, const char *fmt,...)
Identical to rb_compile_warn(), except it also accepts category.
Definition error.c:439
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:466
VALUE rb_eException
Mother of all exceptions.
Definition error.c:1422
void rb_warning(const char *fmt,...)
Issues a warning.
Definition error.c:497
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
Definition error.h:48
VALUE rb_mKernel
Kernel module.
Definition object.c:60
VALUE rb_cModule
Module class.
Definition object.c:62
VALUE rb_equal(VALUE lhs, VALUE rhs)
This function is an optimised version of calling #==.
Definition object.c:177
#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_new_from_values(long n, const VALUE *elts)
Identical to rb_ary_new_from_args(), except how objects are passed.
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_freeze(VALUE obj)
Freeze an array, preventing further modifications.
void rb_undef(VALUE mod, ID mid)
Inserts a method entry that hides previous method definition of the given name.
Definition vm_method.c:2271
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
Definition error.h:35
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
Definition error.h:284
#define rb_hash_uint(h, i)
Just another name of st_hash_uint.
Definition string.h:941
st_index_t rb_hash_start(st_index_t i)
Starts a series of hashing.
Definition random.c:1776
VALUE rb_mod_name(VALUE mod)
Queries the name of a module.
Definition variable.c:136
int rb_respond_to(VALUE obj, ID mid)
Queries if the object responds to the method.
Definition vm_method.c:3359
VALUE(* rb_alloc_func_t)(VALUE klass)
This is the type of functions that ruby calls when trying to allocate an object.
Definition vm.h:216
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
Definition vm_method.c:1622
void rb_alias(VALUE klass, ID dst, ID src)
Resembles alias.
Definition vm_method.c:2654
void rb_attr(VALUE klass, ID name, int need_reader, int need_writer, int honour_visibility)
This function resembles now-deprecated Module#attr.
Definition vm_method.c:2234
void rb_remove_method(VALUE klass, const char *name)
Removes a method.
Definition vm_method.c:2083
rb_alloc_func_t rb_get_alloc_func(VALUE klass)
Queries the allocator function of a class.
Definition vm_method.c:1628
void rb_clear_constant_cache_for_id(ID id)
Clears the inline constant caches associated with a particular ID.
Definition vm_method.c:320
void rb_remove_method_id(VALUE klass, ID mid)
Identical to rb_remove_method(), except it accepts the method name as ID.
Definition vm_method.c:2077
void rb_define_alloc_func(VALUE klass, rb_alloc_func_t func)
Sets the allocator function of a class.
VALUE rb_f_notimplement(int argc, const VALUE *argv, VALUE obj, VALUE marker)
Raises rb_eNotImpError.
Definition vm_method.c:791
int rb_method_boundp(VALUE klass, ID id, int ex)
Queries if the klass has this method.
Definition vm_method.c:2195
int rb_obj_respond_to(VALUE obj, ID mid, int private_p)
Identical to rb_respond_to(), except it additionally takes the visibility parameter.
Definition vm_method.c:3343
ID rb_check_id(volatile VALUE *namep)
Detects if the given name is already interned or not.
Definition symbol.c:1133
VALUE rb_to_symbol(VALUE name)
Identical to rb_intern_str(), except it generates a dynamic symbol if necessary.
Definition string.c:12715
ID rb_to_id(VALUE str)
Definition string.c:12705
int capa
Designed capacity of the buffer.
Definition io.h:11
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 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 RB_NO_KEYWORDS
Do not pass keywords.
Definition scan_args.h:69
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
Definition stdarg.h:35
#define ANYARGS
Functions declared using this macro take arbitrary arguments, including void.
Definition stdarg.h:64
Definition vm_method.c:379
Definition method.h:63
CREF (Class REFerence)
Definition method.h:45
This is the struct that holds necessary info for a struct.
Definition rtypeddata.h:202
size_t(* dsize)(const void *)
This function is to query the size of the underlying memory regions.
Definition rtypeddata.h:242
RUBY_DATA_FUNC dfree
This function is called when the object is no longer used.
Definition rtypeddata.h:232
struct rb_data_type_struct::@54 function
Function pointers.
const char * wrap_struct_name
Name of structs of this kind.
Definition rtypeddata.h:209
VALUE flags
Type-specific behavioural characteristics.
Definition rtypeddata.h:311
Definition method.h:55
rb_cref_t * cref
class reference, should be marked
Definition method.h:144
const rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
Definition method.h:143
Definition st.h:79
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
static void Check_Type(VALUE v, enum ruby_value_type t)
Identical to RB_TYPE_P(), except it raises exceptions on predication failure.
Definition value_type.h:433
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
Definition value_type.h:376