Ruby 4.0.10p0 (2026-11-19 revision a704b7cd95a42cc0cf5f307137bf3aac0285b915)
gc.c
1/**********************************************************************
2
3 gc.c -
4
5 $Author$
6 created at: Tue Oct 5 09:44:46 JST 1993
7
8 Copyright (C) 1993-2007 Yukihiro Matsumoto
9 Copyright (C) 2000 Network Applied Communication Laboratory, Inc.
10 Copyright (C) 2000 Information-technology Promotion Agency, Japan
11
12**********************************************************************/
13
14#define rb_data_object_alloc rb_data_object_alloc
15#define rb_data_typed_object_alloc rb_data_typed_object_alloc
16
17#include "ruby/internal/config.h"
18#ifdef _WIN32
19# include "ruby/ruby.h"
20#endif
21
22#if defined(__wasm__) && !defined(__EMSCRIPTEN__)
23# include "wasm/setjmp.h"
24# include "wasm/machine.h"
25#else
26# include <setjmp.h>
27#endif
28#include <stdarg.h>
29#include <stdio.h>
30
31/* MALLOC_HEADERS_BEGIN */
32#ifndef HAVE_MALLOC_USABLE_SIZE
33# ifdef _WIN32
34# define HAVE_MALLOC_USABLE_SIZE
35# define malloc_usable_size(a) _msize(a)
36# elif defined HAVE_MALLOC_SIZE
37# define HAVE_MALLOC_USABLE_SIZE
38# define malloc_usable_size(a) malloc_size(a)
39# endif
40#endif
41
42#ifdef HAVE_MALLOC_USABLE_SIZE
43# ifdef RUBY_ALTERNATIVE_MALLOC_HEADER
44/* Alternative malloc header is included in ruby/missing.h */
45# elif defined(HAVE_MALLOC_H)
46# include <malloc.h>
47# elif defined(HAVE_MALLOC_NP_H)
48# include <malloc_np.h>
49# elif defined(HAVE_MALLOC_MALLOC_H)
50# include <malloc/malloc.h>
51# endif
52#endif
53
54/* MALLOC_HEADERS_END */
55
56#ifdef HAVE_SYS_TIME_H
57# include <sys/time.h>
58#endif
59
60#ifdef HAVE_SYS_RESOURCE_H
61# include <sys/resource.h>
62#endif
63
64#if defined _WIN32 || defined __CYGWIN__
65# include <windows.h>
66#elif defined(HAVE_POSIX_MEMALIGN)
67#elif defined(HAVE_MEMALIGN)
68# include <malloc.h>
69#endif
70
71#include <sys/types.h>
72
73#ifdef __EMSCRIPTEN__
74#include <emscripten.h>
75#endif
76
77/* For ruby_annotate_mmap */
78#ifdef HAVE_SYS_PRCTL_H
79#include <sys/prctl.h>
80#endif
81
82#undef LIST_HEAD /* ccan/list conflicts with BSD-origin sys/queue.h. */
83
84#include "constant.h"
85#include "darray.h"
86#include "debug_counter.h"
87#include "eval_intern.h"
88#include "gc/gc.h"
89#include "id_table.h"
90#include "internal.h"
91#include "internal/class.h"
92#include "internal/compile.h"
93#include "internal/complex.h"
94#include "internal/concurrent_set.h"
95#include "internal/cont.h"
96#include "internal/error.h"
97#include "internal/eval.h"
98#include "internal/gc.h"
99#include "internal/hash.h"
100#include "internal/imemo.h"
101#include "internal/io.h"
102#include "internal/numeric.h"
103#include "internal/object.h"
104#include "internal/proc.h"
105#include "internal/rational.h"
106#include "internal/sanitizers.h"
107#include "internal/struct.h"
108#include "internal/symbol.h"
109#include "internal/thread.h"
110#include "internal/variable.h"
111#include "internal/warnings.h"
112#include "probes.h"
113#include "regint.h"
114#include "ruby/debug.h"
115#include "ruby/io.h"
116#include "ruby/re.h"
117#include "ruby/st.h"
118#include "ruby/thread.h"
119#include "ruby/util.h"
120#include "ruby/vm.h"
121#include "ruby_assert.h"
122#include "ruby_atomic.h"
123#include "symbol.h"
124#include "variable.h"
125#include "vm_core.h"
126#include "vm_sync.h"
127#include "vm_callinfo.h"
128#include "ractor_core.h"
129#include "yjit.h"
130#include "zjit.h"
131
132#include "builtin.h"
133#include "shape.h"
134
135unsigned int
136rb_gc_vm_lock(const char *file, int line)
137{
138 unsigned int lev = 0;
139 rb_vm_lock_enter(&lev, file, line);
140 return lev;
141}
142
143void
144rb_gc_vm_unlock(unsigned int lev, const char *file, int line)
145{
146 rb_vm_lock_leave(&lev, file, line);
147}
148
149unsigned int
150rb_gc_cr_lock(const char *file, int line)
151{
152 unsigned int lev;
153 rb_vm_lock_enter_cr(GET_RACTOR(), &lev, file, line);
154 return lev;
155}
156
157void
158rb_gc_cr_unlock(unsigned int lev, const char *file, int line)
159{
160 rb_vm_lock_leave_cr(GET_RACTOR(), &lev, file, line);
161}
162
163unsigned int
164rb_gc_vm_lock_no_barrier(const char *file, int line)
165{
166 unsigned int lev = 0;
167 rb_vm_lock_enter_nb(&lev, file, line);
168 return lev;
169}
170
171void
172rb_gc_vm_unlock_no_barrier(unsigned int lev, const char *file, int line)
173{
174 rb_vm_lock_leave_nb(&lev, file, line);
175}
176
177void
178rb_gc_vm_barrier(void)
179{
180 rb_vm_barrier();
181}
182
183void *
184rb_gc_get_ractor_newobj_cache(void)
185{
186 return GET_RACTOR()->newobj_cache;
187}
188
189#if USE_MODULAR_GC
190void
191rb_gc_initialize_vm_context(struct rb_gc_vm_context *context)
192{
193 rb_native_mutex_initialize(&context->lock);
194 context->ec = GET_EC();
195}
196
197void
198rb_gc_worker_thread_set_vm_context(struct rb_gc_vm_context *context)
199{
200 rb_native_mutex_lock(&context->lock);
201
202 GC_ASSERT(rb_current_execution_context(false) == NULL);
203
204#ifdef RB_THREAD_LOCAL_SPECIFIER
205 rb_current_ec_set(context->ec);
206#else
207 native_tls_set(ruby_current_ec_key, context->ec);
208#endif
209}
210
211void
212rb_gc_worker_thread_unset_vm_context(struct rb_gc_vm_context *context)
213{
214 rb_native_mutex_unlock(&context->lock);
215
216 GC_ASSERT(rb_current_execution_context(true) == context->ec);
217
218#ifdef RB_THREAD_LOCAL_SPECIFIER
219 rb_current_ec_set(NULL);
220#else
221 native_tls_set(ruby_current_ec_key, NULL);
222#endif
223}
224#endif
225
226bool
227rb_gc_event_hook_required_p(rb_event_flag_t event)
228{
229 return ruby_vm_event_flags & event;
230}
231
232void
233rb_gc_event_hook(VALUE obj, rb_event_flag_t event)
234{
235 if (LIKELY(!rb_gc_event_hook_required_p(event))) return;
236
237 rb_execution_context_t *ec = GET_EC();
238 if (!ec->cfp) return;
239
240 EXEC_EVENT_HOOK(ec, event, ec->cfp->self, 0, 0, 0, obj);
241}
242
243void *
244rb_gc_get_objspace(void)
245{
246 return GET_VM()->gc.objspace;
247}
248
249
250void
251rb_gc_ractor_newobj_cache_foreach(void (*func)(void *cache, void *data), void *data)
252{
253 rb_ractor_t *r = NULL;
254 if (RB_LIKELY(ruby_single_main_ractor)) {
255 GC_ASSERT(
256 ccan_list_empty(&GET_VM()->ractor.set) ||
257 (ccan_list_top(&GET_VM()->ractor.set, rb_ractor_t, vmlr_node) == ruby_single_main_ractor &&
258 ccan_list_tail(&GET_VM()->ractor.set, rb_ractor_t, vmlr_node) == ruby_single_main_ractor)
259 );
260
261 func(ruby_single_main_ractor->newobj_cache, data);
262 }
263 else {
264 ccan_list_for_each(&GET_VM()->ractor.set, r, vmlr_node) {
265 func(r->newobj_cache, data);
266 }
267 }
268}
269
270void
271rb_gc_run_obj_finalizer(VALUE objid, long count, VALUE (*callback)(long i, void *data), void *data)
272{
273 volatile struct {
274 VALUE errinfo;
275 VALUE final;
276 rb_control_frame_t *cfp;
277 VALUE *sp;
278 long finished;
279 } saved;
280
281 rb_execution_context_t * volatile ec = GET_EC();
282#define RESTORE_FINALIZER() (\
283 ec->cfp = saved.cfp, \
284 ec->cfp->sp = saved.sp, \
285 ec->errinfo = saved.errinfo)
286
287 saved.errinfo = ec->errinfo;
288 saved.cfp = ec->cfp;
289 saved.sp = ec->cfp->sp;
290 saved.finished = 0;
291 saved.final = Qundef;
292
293 ASSERT_vm_unlocking();
294 rb_ractor_ignore_belonging(true);
295 EC_PUSH_TAG(ec);
296 enum ruby_tag_type state = EC_EXEC_TAG();
297 if (state != TAG_NONE) {
298 ++saved.finished; /* skip failed finalizer */
299
300 VALUE failed_final = saved.final;
301 saved.final = Qundef;
302 if (!UNDEF_P(failed_final) && !NIL_P(ruby_verbose)) {
303 rb_warn("Exception in finalizer %+"PRIsVALUE, failed_final);
304 rb_ec_error_print(ec, ec->errinfo);
305 }
306 }
307
308 for (long i = saved.finished; RESTORE_FINALIZER(), i < count; saved.finished = ++i) {
309 saved.final = callback(i, data);
310 rb_check_funcall(saved.final, idCall, 1, &objid);
311 }
312 EC_POP_TAG();
313 rb_ractor_ignore_belonging(false);
314#undef RESTORE_FINALIZER
315}
316
317void
318rb_gc_set_pending_interrupt(void)
319{
320 rb_execution_context_t *ec = GET_EC();
321 ec->interrupt_mask |= PENDING_INTERRUPT_MASK;
322}
323
324void
325rb_gc_unset_pending_interrupt(void)
326{
327 rb_execution_context_t *ec = GET_EC();
328 ec->interrupt_mask &= ~PENDING_INTERRUPT_MASK;
329}
330
331bool
332rb_gc_multi_ractor_p(void)
333{
334 return rb_multi_ractor_p();
335}
336
337bool
338rb_gc_shutdown_call_finalizer_p(VALUE obj)
339{
340 switch (BUILTIN_TYPE(obj)) {
341 case T_DATA:
342 if (!ruby_free_at_exit_p() && (!DATA_PTR(obj) || !RDATA(obj)->dfree)) return false;
343 if (rb_obj_is_thread(obj)) return false;
344 if (rb_obj_is_mutex(obj)) return false;
345 if (rb_obj_is_fiber(obj)) return false;
346 if (rb_ractor_p(obj)) return false;
347 if (rb_obj_is_fstring_table(obj)) return false;
348 if (rb_obj_is_symbol_table(obj)) return false;
349
350 return true;
351
352 case T_FILE:
353 return true;
354
355 case T_SYMBOL:
356 return true;
357
358 case T_NONE:
359 return false;
360
361 default:
362 return ruby_free_at_exit_p();
363 }
364}
365
366uint32_t
367rb_gc_get_shape(VALUE obj)
368{
369 return (uint32_t)rb_obj_shape_id(obj);
370}
371
372void
373rb_gc_set_shape(VALUE obj, uint32_t shape_id)
374{
375 RBASIC_SET_SHAPE_ID(obj, (uint32_t)shape_id);
376}
377
378uint32_t
379rb_gc_rebuild_shape(VALUE obj, size_t heap_id)
380{
381 RUBY_ASSERT(RB_TYPE_P(obj, T_OBJECT));
382
383 return (uint32_t)rb_shape_transition_heap(obj, heap_id);
384}
385
386void rb_vm_update_references(void *ptr);
387
388#define rb_setjmp(env) RUBY_SETJMP(env)
389#define rb_jmp_buf rb_jmpbuf_t
390#undef rb_data_object_wrap
391
392#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
393#define MAP_ANONYMOUS MAP_ANON
394#endif
395
396#define unless_objspace(objspace) \
397 void *objspace; \
398 rb_vm_t *unless_objspace_vm = GET_VM(); \
399 if (unless_objspace_vm) objspace = unless_objspace_vm->gc.objspace; \
400 else /* return; or objspace will be warned uninitialized */
401
402#define RMOVED(obj) ((struct RMoved *)(obj))
403
404#define TYPED_UPDATE_IF_MOVED(_objspace, _type, _thing) do { \
405 if (gc_object_moved_p_internal((_objspace), (VALUE)(_thing))) { \
406 *(_type *)&(_thing) = (_type)gc_location_internal(_objspace, (VALUE)_thing); \
407 } \
408} while (0)
409
410#define UPDATE_IF_MOVED(_objspace, _thing) TYPED_UPDATE_IF_MOVED(_objspace, VALUE, _thing)
411
412#if RUBY_MARK_FREE_DEBUG
413int ruby_gc_debug_indent = 0;
414#endif
415
416#ifndef RGENGC_OBJ_INFO
417# define RGENGC_OBJ_INFO RGENGC_CHECK_MODE
418#endif
419
420#ifndef CALC_EXACT_MALLOC_SIZE
421# define CALC_EXACT_MALLOC_SIZE 0
422#endif
423
425
426static size_t malloc_offset = 0;
427#if defined(HAVE_MALLOC_USABLE_SIZE)
428static size_t
429gc_compute_malloc_offset(void)
430{
431 // Different allocators use different metadata storage strategies which result in different
432 // ideal sizes.
433 // For instance malloc(64) will waste 8B with glibc, but waste 0B with jemalloc.
434 // But malloc(56) will waste 0B with glibc, but waste 8B with jemalloc.
435 // So we try allocating 64, 56 and 48 bytes and select the first offset that doesn't
436 // waste memory.
437 // This was tested on Linux with glibc 2.35 and jemalloc 5, and for both it result in
438 // no wasted memory.
439 size_t offset = 0;
440 for (offset = 0; offset <= 16; offset += 8) {
441 size_t allocated = (64 - offset);
442 void *test_ptr = malloc(allocated);
443 size_t wasted = malloc_usable_size(test_ptr) - allocated;
444 free(test_ptr);
445
446 if (wasted == 0) {
447 return offset;
448 }
449 }
450 return 0;
451}
452#else
453static size_t
454gc_compute_malloc_offset(void)
455{
456 // If we don't have malloc_usable_size, we use powers of 2.
457 return 0;
458}
459#endif
460
461size_t
462rb_malloc_grow_capa(size_t current, size_t type_size)
463{
464 size_t current_capacity = current;
465 if (current_capacity < 4) {
466 current_capacity = 4;
467 }
468 current_capacity *= type_size;
469
470 // We double the current capacity.
471 size_t new_capacity = (current_capacity * 2);
472
473 // And round up to the next power of 2 if it's not already one.
474 if (rb_popcount64(new_capacity) != 1) {
475 new_capacity = (size_t)(1 << (64 - nlz_int64(new_capacity)));
476 }
477
478 new_capacity -= malloc_offset;
479 new_capacity /= type_size;
480 if (current > new_capacity) {
481 rb_bug("rb_malloc_grow_capa: current_capacity=%zu, new_capacity=%zu, malloc_offset=%zu", current, new_capacity, malloc_offset);
482 }
483 RUBY_ASSERT(new_capacity > current);
484 return new_capacity;
485}
486
487static inline struct rbimpl_size_overflow_tag
488size_mul_add_overflow(size_t x, size_t y, size_t z) /* x * y + z */
489{
490 struct rbimpl_size_overflow_tag t = rbimpl_size_mul_overflow(x, y);
491 struct rbimpl_size_overflow_tag u = rbimpl_size_add_overflow(t.result, z);
492 return (struct rbimpl_size_overflow_tag) { t.overflowed || u.overflowed, u.result };
493}
494
495static inline struct rbimpl_size_overflow_tag
496size_mul_add_mul_overflow(size_t x, size_t y, size_t z, size_t w) /* x * y + z * w */
497{
498 struct rbimpl_size_overflow_tag t = rbimpl_size_mul_overflow(x, y);
499 struct rbimpl_size_overflow_tag u = rbimpl_size_mul_overflow(z, w);
500 struct rbimpl_size_overflow_tag v = rbimpl_size_add_overflow(t.result, u.result);
501 return (struct rbimpl_size_overflow_tag) { t.overflowed || u.overflowed || v.overflowed, v.result };
502}
503
504PRINTF_ARGS(NORETURN(static void gc_raise(VALUE, const char*, ...)), 2, 3);
505
506static inline size_t
507size_mul_or_raise(size_t x, size_t y, VALUE exc)
508{
509 struct rbimpl_size_overflow_tag t = rbimpl_size_mul_overflow(x, y);
510 if (LIKELY(!t.overflowed)) {
511 return t.result;
512 }
513 else if (rb_during_gc()) {
514 rb_memerror(); /* or...? */
515 }
516 else {
517 gc_raise(
518 exc,
519 "integer overflow: %"PRIuSIZE
520 " * %"PRIuSIZE
521 " > %"PRIuSIZE,
522 x, y, (size_t)SIZE_MAX);
523 }
524}
525
526size_t
527rb_size_mul_or_raise(size_t x, size_t y, VALUE exc)
528{
529 return size_mul_or_raise(x, y, exc);
530}
531
532static inline size_t
533size_mul_add_or_raise(size_t x, size_t y, size_t z, VALUE exc)
534{
535 struct rbimpl_size_overflow_tag t = size_mul_add_overflow(x, y, z);
536 if (LIKELY(!t.overflowed)) {
537 return t.result;
538 }
539 else if (rb_during_gc()) {
540 rb_memerror(); /* or...? */
541 }
542 else {
543 gc_raise(
544 exc,
545 "integer overflow: %"PRIuSIZE
546 " * %"PRIuSIZE
547 " + %"PRIuSIZE
548 " > %"PRIuSIZE,
549 x, y, z, (size_t)SIZE_MAX);
550 }
551}
552
553size_t
554rb_size_mul_add_or_raise(size_t x, size_t y, size_t z, VALUE exc)
555{
556 return size_mul_add_or_raise(x, y, z, exc);
557}
558
559static inline size_t
560size_mul_add_mul_or_raise(size_t x, size_t y, size_t z, size_t w, VALUE exc)
561{
562 struct rbimpl_size_overflow_tag t = size_mul_add_mul_overflow(x, y, z, w);
563 if (LIKELY(!t.overflowed)) {
564 return t.result;
565 }
566 else if (rb_during_gc()) {
567 rb_memerror(); /* or...? */
568 }
569 else {
570 gc_raise(
571 exc,
572 "integer overflow: %"PRIdSIZE
573 " * %"PRIdSIZE
574 " + %"PRIdSIZE
575 " * %"PRIdSIZE
576 " > %"PRIdSIZE,
577 x, y, z, w, (size_t)SIZE_MAX);
578 }
579}
580
581#if defined(HAVE_RB_GC_GUARDED_PTR_VAL) && HAVE_RB_GC_GUARDED_PTR_VAL
582/* trick the compiler into thinking a external signal handler uses this */
583volatile VALUE rb_gc_guarded_val;
584volatile VALUE *
585rb_gc_guarded_ptr_val(volatile VALUE *ptr, VALUE val)
586{
587 rb_gc_guarded_val = val;
588
589 return ptr;
590}
591#endif
592
593static const char *obj_type_name(VALUE obj);
594#include "gc/default/default.c"
595
596#if USE_MODULAR_GC && !defined(HAVE_DLOPEN)
597# error "Modular GC requires dlopen"
598#elif USE_MODULAR_GC
599#include <dlfcn.h>
600
601typedef struct gc_function_map {
602 // Bootup
603 void *(*objspace_alloc)(void);
604 void (*objspace_init)(void *objspace_ptr);
605 void *(*ractor_cache_alloc)(void *objspace_ptr, void *ractor);
606 void (*set_params)(void *objspace_ptr);
607 void (*init)(void);
608 size_t *(*heap_sizes)(void *objspace_ptr);
609 // Shutdown
610 void (*shutdown_free_objects)(void *objspace_ptr);
611 void (*objspace_free)(void *objspace_ptr);
612 void (*ractor_cache_free)(void *objspace_ptr, void *cache);
613 // GC
614 void (*start)(void *objspace_ptr, bool full_mark, bool immediate_mark, bool immediate_sweep, bool compact);
615 bool (*during_gc_p)(void *objspace_ptr);
616 void (*prepare_heap)(void *objspace_ptr);
617 void (*gc_enable)(void *objspace_ptr);
618 void (*gc_disable)(void *objspace_ptr, bool finish_current_gc);
619 bool (*gc_enabled_p)(void *objspace_ptr);
620 VALUE (*config_get)(void *objpace_ptr);
621 void (*config_set)(void *objspace_ptr, VALUE hash);
622 void (*stress_set)(void *objspace_ptr, VALUE flag);
623 VALUE (*stress_get)(void *objspace_ptr);
624 // Object allocation
625 VALUE (*new_obj)(void *objspace_ptr, void *cache_ptr, VALUE klass, VALUE flags, bool wb_protected, size_t alloc_size);
626 size_t (*obj_slot_size)(VALUE obj);
627 size_t (*heap_id_for_size)(void *objspace_ptr, size_t size);
628 bool (*size_allocatable_p)(size_t size);
629 // Malloc
630 void *(*malloc)(void *objspace_ptr, size_t size, bool gc_allowed);
631 void *(*calloc)(void *objspace_ptr, size_t size, bool gc_allowed);
632 void *(*realloc)(void *objspace_ptr, void *ptr, size_t new_size, size_t old_size, bool gc_allowed);
633 void (*free)(void *objspace_ptr, void *ptr, size_t old_size);
634 void (*adjust_memory_usage)(void *objspace_ptr, ssize_t diff);
635 // Marking
636 void (*mark)(void *objspace_ptr, VALUE obj);
637 void (*mark_and_move)(void *objspace_ptr, VALUE *ptr);
638 void (*mark_and_pin)(void *objspace_ptr, VALUE obj);
639 void (*mark_maybe)(void *objspace_ptr, VALUE obj);
640 void (*mark_weak)(void *objspace_ptr, VALUE *ptr);
641 void (*remove_weak)(void *objspace_ptr, VALUE parent_obj, VALUE *ptr);
642 // Compaction
643 bool (*object_moved_p)(void *objspace_ptr, VALUE obj);
644 bool (*pinned_p)(void *objspace_ptr, VALUE obj);
645 VALUE (*location)(void *objspace_ptr, VALUE value);
646 // Write barriers
647 void (*writebarrier)(void *objspace_ptr, VALUE a, VALUE b);
648 void (*writebarrier_unprotect)(void *objspace_ptr, VALUE obj);
649 void (*writebarrier_remember)(void *objspace_ptr, VALUE obj);
650 // Heap walking
651 void (*each_objects)(void *objspace_ptr, int (*callback)(void *, void *, size_t, void *), void *data);
652 void (*each_object)(void *objspace_ptr, void (*func)(VALUE obj, void *data), void *data);
653 // Finalizers
654 void (*make_zombie)(void *objspace_ptr, VALUE obj, void (*dfree)(void *), void *data);
655 VALUE (*define_finalizer)(void *objspace_ptr, VALUE obj, VALUE block);
656 void (*undefine_finalizer)(void *objspace_ptr, VALUE obj);
657 void (*copy_finalizer)(void *objspace_ptr, VALUE dest, VALUE obj);
658 void (*shutdown_call_finalizer)(void *objspace_ptr);
659 // Forking
660 void (*before_fork)(void *objspace_ptr);
661 void (*after_fork)(void *objspace_ptr, rb_pid_t pid);
662 // Statistics
663 void (*set_measure_total_time)(void *objspace_ptr, VALUE flag);
664 bool (*get_measure_total_time)(void *objspace_ptr);
665 unsigned long long (*get_total_time)(void *objspace_ptr);
666 size_t (*gc_count)(void *objspace_ptr);
667 VALUE (*latest_gc_info)(void *objspace_ptr, VALUE key);
668 VALUE (*stat)(void *objspace_ptr, VALUE hash_or_sym);
669 VALUE (*stat_heap)(void *objspace_ptr, VALUE heap_name, VALUE hash_or_sym);
670 const char *(*active_gc_name)(void);
671 // Miscellaneous
672 struct rb_gc_object_metadata_entry *(*object_metadata)(void *objspace_ptr, VALUE obj);
673 bool (*pointer_to_heap_p)(void *objspace_ptr, const void *ptr);
674 bool (*garbage_object_p)(void *objspace_ptr, VALUE obj);
675 void (*set_event_hook)(void *objspace_ptr, const rb_event_flag_t event);
676 void (*copy_attributes)(void *objspace_ptr, VALUE dest, VALUE obj);
677
678 bool modular_gc_loaded_p;
679} rb_gc_function_map_t;
680
681static rb_gc_function_map_t rb_gc_functions;
682
683# define RUBY_GC_LIBRARY "RUBY_GC_LIBRARY"
684# define MODULAR_GC_DIR STRINGIZE(modular_gc_dir)
685
686static void
687ruby_modular_gc_init(void)
688{
689 // Assert that the directory path ends with a /
690 RUBY_ASSERT_ALWAYS(MODULAR_GC_DIR[sizeof(MODULAR_GC_DIR) - 2] == '/');
691
692 const char *gc_so_file = getenv(RUBY_GC_LIBRARY);
693
694 rb_gc_function_map_t gc_functions = { 0 };
695
696 char *gc_so_path = NULL;
697 void *handle = NULL;
698 if (gc_so_file) {
699 /* Check to make sure that gc_so_file matches /[\w-_]+/ so that it does
700 * not load a shared object outside of the directory. */
701 for (size_t i = 0; i < strlen(gc_so_file); i++) {
702 char c = gc_so_file[i];
703 if (isalnum(c)) continue;
704 switch (c) {
705 case '-':
706 case '_':
707 break;
708 default:
709 fprintf(stderr, "Only alphanumeric, dash, and underscore is allowed in "RUBY_GC_LIBRARY"\n");
710 exit(1);
711 }
712 }
713
714 size_t gc_so_path_size = strlen(MODULAR_GC_DIR "librubygc." DLEXT) + strlen(gc_so_file) + 1;
715#ifdef LOAD_RELATIVE
716 Dl_info dli;
717 size_t prefix_len = 0;
718 if (dladdr((void *)(uintptr_t)ruby_modular_gc_init, &dli)) {
719 const char *base = strrchr(dli.dli_fname, '/');
720 if (base) {
721 size_t tail = 0;
722# define end_with_p(lit) \
723 (prefix_len >= (tail = rb_strlen_lit(lit)) && \
724 memcmp(base - tail, lit, tail) == 0)
725
726 prefix_len = base - dli.dli_fname;
727 if (end_with_p("/bin") || end_with_p("/lib")) {
728 prefix_len -= tail;
729 }
730 prefix_len += MODULAR_GC_DIR[0] != '/';
731 gc_so_path_size += prefix_len;
732 }
733 }
734#endif
735 gc_so_path = alloca(gc_so_path_size);
736 {
737 size_t gc_so_path_idx = 0;
738#define GC_SO_PATH_APPEND(str) do { \
739 gc_so_path_idx += strlcpy(gc_so_path + gc_so_path_idx, str, gc_so_path_size - gc_so_path_idx); \
740} while (0)
741#ifdef LOAD_RELATIVE
742 if (prefix_len > 0) {
743 memcpy(gc_so_path, dli.dli_fname, prefix_len);
744 gc_so_path_idx = prefix_len;
745 }
746#endif
747 GC_SO_PATH_APPEND(MODULAR_GC_DIR "librubygc.");
748 GC_SO_PATH_APPEND(gc_so_file);
749 GC_SO_PATH_APPEND(DLEXT);
750 GC_ASSERT(gc_so_path_idx == gc_so_path_size - 1);
751#undef GC_SO_PATH_APPEND
752 }
753
754 handle = dlopen(gc_so_path, RTLD_LAZY | RTLD_GLOBAL);
755 if (!handle) {
756 fprintf(stderr, "ruby_modular_gc_init: Shared library %s cannot be opened: %s\n", gc_so_path, dlerror());
757 exit(1);
758 }
759
760 gc_functions.modular_gc_loaded_p = true;
761 }
762
763# define load_modular_gc_func(name) do { \
764 if (handle) { \
765 const char *func_name = "rb_gc_impl_" #name; \
766 gc_functions.name = dlsym(handle, func_name); \
767 if (!gc_functions.name) { \
768 fprintf(stderr, "ruby_modular_gc_init: %s function not exported by library %s\n", func_name, gc_so_path); \
769 exit(1); \
770 } \
771 } \
772 else { \
773 gc_functions.name = rb_gc_impl_##name; \
774 } \
775} while (0)
776
777 // Bootup
778 load_modular_gc_func(objspace_alloc);
779 load_modular_gc_func(objspace_init);
780 load_modular_gc_func(ractor_cache_alloc);
781 load_modular_gc_func(set_params);
782 load_modular_gc_func(init);
783 load_modular_gc_func(heap_sizes);
784 // Shutdown
785 load_modular_gc_func(shutdown_free_objects);
786 load_modular_gc_func(objspace_free);
787 load_modular_gc_func(ractor_cache_free);
788 // GC
789 load_modular_gc_func(start);
790 load_modular_gc_func(during_gc_p);
791 load_modular_gc_func(prepare_heap);
792 load_modular_gc_func(gc_enable);
793 load_modular_gc_func(gc_disable);
794 load_modular_gc_func(gc_enabled_p);
795 load_modular_gc_func(config_set);
796 load_modular_gc_func(config_get);
797 load_modular_gc_func(stress_set);
798 load_modular_gc_func(stress_get);
799 // Object allocation
800 load_modular_gc_func(new_obj);
801 load_modular_gc_func(obj_slot_size);
802 load_modular_gc_func(heap_id_for_size);
803 load_modular_gc_func(size_allocatable_p);
804 // Malloc
805 load_modular_gc_func(malloc);
806 load_modular_gc_func(calloc);
807 load_modular_gc_func(realloc);
808 load_modular_gc_func(free);
809 load_modular_gc_func(adjust_memory_usage);
810 // Marking
811 load_modular_gc_func(mark);
812 load_modular_gc_func(mark_and_move);
813 load_modular_gc_func(mark_and_pin);
814 load_modular_gc_func(mark_maybe);
815 load_modular_gc_func(mark_weak);
816 load_modular_gc_func(remove_weak);
817 // Compaction
818 load_modular_gc_func(object_moved_p);
819 load_modular_gc_func(pinned_p);
820 load_modular_gc_func(location);
821 // Write barriers
822 load_modular_gc_func(writebarrier);
823 load_modular_gc_func(writebarrier_unprotect);
824 load_modular_gc_func(writebarrier_remember);
825 // Heap walking
826 load_modular_gc_func(each_objects);
827 load_modular_gc_func(each_object);
828 // Finalizers
829 load_modular_gc_func(make_zombie);
830 load_modular_gc_func(define_finalizer);
831 load_modular_gc_func(undefine_finalizer);
832 load_modular_gc_func(copy_finalizer);
833 load_modular_gc_func(shutdown_call_finalizer);
834 // Forking
835 load_modular_gc_func(before_fork);
836 load_modular_gc_func(after_fork);
837 // Statistics
838 load_modular_gc_func(set_measure_total_time);
839 load_modular_gc_func(get_measure_total_time);
840 load_modular_gc_func(get_total_time);
841 load_modular_gc_func(gc_count);
842 load_modular_gc_func(latest_gc_info);
843 load_modular_gc_func(stat);
844 load_modular_gc_func(stat_heap);
845 load_modular_gc_func(active_gc_name);
846 // Miscellaneous
847 load_modular_gc_func(object_metadata);
848 load_modular_gc_func(pointer_to_heap_p);
849 load_modular_gc_func(garbage_object_p);
850 load_modular_gc_func(set_event_hook);
851 load_modular_gc_func(copy_attributes);
852
853# undef load_modular_gc_func
854
855 rb_gc_functions = gc_functions;
856}
857
858// Bootup
859# define rb_gc_impl_objspace_alloc rb_gc_functions.objspace_alloc
860# define rb_gc_impl_objspace_init rb_gc_functions.objspace_init
861# define rb_gc_impl_ractor_cache_alloc rb_gc_functions.ractor_cache_alloc
862# define rb_gc_impl_set_params rb_gc_functions.set_params
863# define rb_gc_impl_init rb_gc_functions.init
864# define rb_gc_impl_heap_sizes rb_gc_functions.heap_sizes
865// Shutdown
866# define rb_gc_impl_shutdown_free_objects rb_gc_functions.shutdown_free_objects
867# define rb_gc_impl_objspace_free rb_gc_functions.objspace_free
868# define rb_gc_impl_ractor_cache_free rb_gc_functions.ractor_cache_free
869// GC
870# define rb_gc_impl_start rb_gc_functions.start
871# define rb_gc_impl_during_gc_p rb_gc_functions.during_gc_p
872# define rb_gc_impl_prepare_heap rb_gc_functions.prepare_heap
873# define rb_gc_impl_gc_enable rb_gc_functions.gc_enable
874# define rb_gc_impl_gc_disable rb_gc_functions.gc_disable
875# define rb_gc_impl_gc_enabled_p rb_gc_functions.gc_enabled_p
876# define rb_gc_impl_config_get rb_gc_functions.config_get
877# define rb_gc_impl_config_set rb_gc_functions.config_set
878# define rb_gc_impl_stress_set rb_gc_functions.stress_set
879# define rb_gc_impl_stress_get rb_gc_functions.stress_get
880// Object allocation
881# define rb_gc_impl_new_obj rb_gc_functions.new_obj
882# define rb_gc_impl_obj_slot_size rb_gc_functions.obj_slot_size
883# define rb_gc_impl_heap_id_for_size rb_gc_functions.heap_id_for_size
884# define rb_gc_impl_size_allocatable_p rb_gc_functions.size_allocatable_p
885// Malloc
886# define rb_gc_impl_malloc rb_gc_functions.malloc
887# define rb_gc_impl_calloc rb_gc_functions.calloc
888# define rb_gc_impl_realloc rb_gc_functions.realloc
889# define rb_gc_impl_free rb_gc_functions.free
890# define rb_gc_impl_adjust_memory_usage rb_gc_functions.adjust_memory_usage
891// Marking
892# define rb_gc_impl_mark rb_gc_functions.mark
893# define rb_gc_impl_mark_and_move rb_gc_functions.mark_and_move
894# define rb_gc_impl_mark_and_pin rb_gc_functions.mark_and_pin
895# define rb_gc_impl_mark_maybe rb_gc_functions.mark_maybe
896# define rb_gc_impl_mark_weak rb_gc_functions.mark_weak
897# define rb_gc_impl_remove_weak rb_gc_functions.remove_weak
898// Compaction
899# define rb_gc_impl_object_moved_p rb_gc_functions.object_moved_p
900# define rb_gc_impl_pinned_p rb_gc_functions.pinned_p
901# define rb_gc_impl_location rb_gc_functions.location
902// Write barriers
903# define rb_gc_impl_writebarrier rb_gc_functions.writebarrier
904# define rb_gc_impl_writebarrier_unprotect rb_gc_functions.writebarrier_unprotect
905# define rb_gc_impl_writebarrier_remember rb_gc_functions.writebarrier_remember
906// Heap walking
907# define rb_gc_impl_each_objects rb_gc_functions.each_objects
908# define rb_gc_impl_each_object rb_gc_functions.each_object
909// Finalizers
910# define rb_gc_impl_make_zombie rb_gc_functions.make_zombie
911# define rb_gc_impl_define_finalizer rb_gc_functions.define_finalizer
912# define rb_gc_impl_undefine_finalizer rb_gc_functions.undefine_finalizer
913# define rb_gc_impl_copy_finalizer rb_gc_functions.copy_finalizer
914# define rb_gc_impl_shutdown_call_finalizer rb_gc_functions.shutdown_call_finalizer
915// Forking
916# define rb_gc_impl_before_fork rb_gc_functions.before_fork
917# define rb_gc_impl_after_fork rb_gc_functions.after_fork
918// Statistics
919# define rb_gc_impl_set_measure_total_time rb_gc_functions.set_measure_total_time
920# define rb_gc_impl_get_measure_total_time rb_gc_functions.get_measure_total_time
921# define rb_gc_impl_get_total_time rb_gc_functions.get_total_time
922# define rb_gc_impl_gc_count rb_gc_functions.gc_count
923# define rb_gc_impl_latest_gc_info rb_gc_functions.latest_gc_info
924# define rb_gc_impl_stat rb_gc_functions.stat
925# define rb_gc_impl_stat_heap rb_gc_functions.stat_heap
926# define rb_gc_impl_active_gc_name rb_gc_functions.active_gc_name
927// Miscellaneous
928# define rb_gc_impl_object_metadata rb_gc_functions.object_metadata
929# define rb_gc_impl_pointer_to_heap_p rb_gc_functions.pointer_to_heap_p
930# define rb_gc_impl_garbage_object_p rb_gc_functions.garbage_object_p
931# define rb_gc_impl_set_event_hook rb_gc_functions.set_event_hook
932# define rb_gc_impl_copy_attributes rb_gc_functions.copy_attributes
933#endif
934
935#ifdef RUBY_ASAN_ENABLED
936static void
937asan_death_callback(void)
938{
939 if (GET_VM()) {
940 rb_bug_without_die("ASAN error");
941 }
942}
943#endif
944
945static VALUE initial_stress = Qfalse;
946
947void *
948rb_objspace_alloc(void)
949{
950#if USE_MODULAR_GC
951 ruby_modular_gc_init();
952#endif
953
954 void *objspace = rb_gc_impl_objspace_alloc();
955 ruby_current_vm_ptr->gc.objspace = objspace;
956 rb_gc_impl_objspace_init(objspace);
957 rb_gc_impl_stress_set(objspace, initial_stress);
958
959#ifdef RUBY_ASAN_ENABLED
960 __sanitizer_set_death_callback(asan_death_callback);
961#endif
962
963 return objspace;
964}
965
966void
967rb_objspace_free(void *objspace)
968{
969 rb_gc_impl_objspace_free(objspace);
970}
971
972size_t
973rb_gc_obj_slot_size(VALUE obj)
974{
975 return rb_gc_impl_obj_slot_size(obj);
976}
977
978static inline void
979gc_validate_pc(VALUE obj)
980{
981#if RUBY_DEBUG
982 // IMEMOs and objects without a class (e.g managed id table) are not traceable
983 if (RB_TYPE_P(obj, T_IMEMO) || !CLASS_OF(obj)) return;
984
985 rb_execution_context_t *ec = GET_EC();
986 const rb_control_frame_t *cfp = ec->cfp;
987 if (cfp && VM_FRAME_RUBYFRAME_P(cfp) && cfp->pc) {
988 const VALUE *iseq_encoded = ISEQ_BODY(cfp->iseq)->iseq_encoded;
989 const VALUE *iseq_encoded_end = iseq_encoded + ISEQ_BODY(cfp->iseq)->iseq_size;
990 RUBY_ASSERT(cfp->pc >= iseq_encoded, "PC not set when allocating, breaking tracing");
991 RUBY_ASSERT(cfp->pc <= iseq_encoded_end, "PC not set when allocating, breaking tracing");
992 }
993#endif
994}
995
996static inline VALUE
997newobj_of(rb_ractor_t *cr, VALUE klass, VALUE flags, shape_id_t shape_id, bool wb_protected, size_t size)
998{
999 VALUE obj = rb_gc_impl_new_obj(rb_gc_get_objspace(), cr->newobj_cache, klass, flags, wb_protected, size);
1000 RBASIC_SET_SHAPE_ID_NO_CHECKS(obj, shape_id);
1001
1002 gc_validate_pc(obj);
1003
1004 if (UNLIKELY(rb_gc_event_hook_required_p(RUBY_INTERNAL_EVENT_NEWOBJ))) {
1005 int lev = RB_GC_VM_LOCK_NO_BARRIER();
1006 {
1007 size_t slot_size = rb_gc_obj_slot_size(obj);
1008 memset((char *)obj + sizeof(struct RBasic), 0, slot_size - sizeof(struct RBasic));
1009
1010 /* We must disable GC here because the callback could call xmalloc
1011 * which could potentially trigger a GC, and a lot of code is unsafe
1012 * to trigger a GC right after an object has been allocated because
1013 * they perform initialization for the object and assume that the
1014 * GC does not trigger before then. */
1015 bool gc_disabled = RTEST(rb_gc_disable_no_rest());
1016 {
1017 rb_gc_event_hook(obj, RUBY_INTERNAL_EVENT_NEWOBJ);
1018 }
1019 if (!gc_disabled) rb_gc_enable();
1020 }
1021 RB_GC_VM_UNLOCK_NO_BARRIER(lev);
1022 }
1023
1024#if RGENGC_CHECK_MODE
1025# ifndef GC_DEBUG_SLOT_FILL_SPECIAL_VALUE
1026# define GC_DEBUG_SLOT_FILL_SPECIAL_VALUE 255
1027# endif
1028
1029 memset(
1030 (void *)(obj + sizeof(struct RBasic)),
1031 GC_DEBUG_SLOT_FILL_SPECIAL_VALUE,
1032 rb_gc_obj_slot_size(obj) - sizeof(struct RBasic)
1033 );
1034#endif
1035
1036 return obj;
1037}
1038
1039VALUE
1040rb_wb_unprotected_newobj_of(VALUE klass, VALUE flags, shape_id_t shape_id, size_t size)
1041{
1042 GC_ASSERT((flags & FL_WB_PROTECTED) == 0);
1043 return newobj_of(GET_RACTOR(), klass, flags, shape_id, FALSE, size);
1044}
1045
1046VALUE
1047rb_wb_protected_newobj_of(rb_execution_context_t *ec, VALUE klass, VALUE flags, shape_id_t shape_id, size_t size)
1048{
1049 GC_ASSERT((flags & FL_WB_PROTECTED) == 0);
1050 return newobj_of(rb_ec_ractor_ptr(ec), klass, flags, shape_id, TRUE, size);
1051}
1052
1053#define UNEXPECTED_NODE(func) \
1054 rb_bug(#func"(): GC does not handle T_NODE 0x%x(%p) 0x%"PRIxVALUE, \
1055 BUILTIN_TYPE(obj), (void*)(obj), RBASIC(obj)->flags)
1056
1057static inline void
1058rb_data_object_check(VALUE klass)
1059{
1060 if (klass != rb_cObject && (rb_get_alloc_func(klass) == rb_class_allocate_instance)) {
1061 rb_undef_alloc_func(klass);
1062 rb_warn("undefining the allocator of T_DATA class %"PRIsVALUE, klass);
1063 }
1064}
1065
1066VALUE
1067rb_data_object_wrap(VALUE klass, void *datap, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree)
1068{
1070 if (klass) rb_data_object_check(klass);
1071 VALUE obj = newobj_of(GET_RACTOR(), klass, T_DATA, ROOT_SHAPE_ID, !dmark, sizeof(struct RTypedData));
1072
1073 struct RData *data = (struct RData *)obj;
1074 data->dmark = dmark;
1075 data->dfree = dfree;
1076 data->data = datap;
1077
1078 return obj;
1079}
1080
1081VALUE
1082rb_data_object_zalloc(VALUE klass, size_t size, RUBY_DATA_FUNC dmark, RUBY_DATA_FUNC dfree)
1083{
1084 VALUE obj = rb_data_object_wrap(klass, 0, dmark, dfree);
1085 DATA_PTR(obj) = xcalloc(1, size);
1086 return obj;
1087}
1088
1089static VALUE
1090typed_data_alloc(VALUE klass, VALUE typed_flag, void *datap, const rb_data_type_t *type, size_t size)
1091{
1092 RBIMPL_NONNULL_ARG(type);
1093 if (klass) rb_data_object_check(klass);
1094 bool wb_protected = (type->flags & RUBY_FL_WB_PROTECTED) || !type->function.dmark;
1095 VALUE obj = newobj_of(GET_RACTOR(), klass, T_DATA | RUBY_TYPED_FL_IS_TYPED_DATA, ROOT_SHAPE_ID, wb_protected, size);
1096
1097 struct RTypedData *data = (struct RTypedData *)obj;
1098 data->fields_obj = 0;
1099 *(VALUE *)&data->type = ((VALUE)type) | typed_flag;
1100 data->data = datap;
1101
1102 return obj;
1103}
1104
1105VALUE
1106rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *type)
1107{
1108 if (UNLIKELY(type->flags & RUBY_TYPED_EMBEDDABLE)) {
1109 rb_raise(rb_eTypeError, "Cannot wrap an embeddable TypedData");
1110 }
1111
1112 return typed_data_alloc(klass, 0, datap, type, sizeof(struct RTypedData));
1113}
1114
1115VALUE
1116rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type)
1117{
1118 if (type->flags & RUBY_TYPED_EMBEDDABLE) {
1119 if (!(type->flags & RUBY_TYPED_FREE_IMMEDIATELY)) {
1120 rb_raise(rb_eTypeError, "Embeddable TypedData must be freed immediately");
1121 }
1122
1123 size_t embed_size = offsetof(struct RTypedData, data) + size;
1124 if (rb_gc_size_allocatable_p(embed_size)) {
1125 VALUE obj = typed_data_alloc(klass, TYPED_DATA_EMBEDDED, 0, type, embed_size);
1126 memset((char *)obj + offsetof(struct RTypedData, data), 0, size);
1127 return obj;
1128 }
1129 }
1130
1131 VALUE obj = typed_data_alloc(klass, 0, NULL, type, sizeof(struct RTypedData));
1132 DATA_PTR(obj) = xcalloc(1, size);
1133 return obj;
1134}
1135
1136static size_t
1137rb_objspace_data_type_memsize(VALUE obj)
1138{
1139 size_t size = 0;
1140 if (RTYPEDDATA_P(obj)) {
1141 const void *ptr = RTYPEDDATA_GET_DATA(obj);
1142
1143 if (ptr) {
1144 const rb_data_type_t *type = RTYPEDDATA_TYPE(obj);
1145 if (type->flags & RUBY_TYPED_EMBEDDABLE && !RTYPEDDATA_EMBEDDED_P(obj)) {
1146#ifdef HAVE_MALLOC_USABLE_SIZE
1147 size += malloc_usable_size((void *)ptr);
1148#endif
1149 }
1150
1151 if (type->function.dsize) {
1152 size += type->function.dsize(ptr);
1153 }
1154 }
1155 }
1156
1157 return size;
1158}
1159
1160const char *
1161rb_objspace_data_type_name(VALUE obj)
1162{
1163 if (RTYPEDDATA_P(obj)) {
1164 return RTYPEDDATA_TYPE(obj)->wrap_struct_name;
1165 }
1166 else {
1167 return 0;
1168 }
1169}
1170
1171static void
1172io_fptr_finalize(void *fptr)
1173{
1174 rb_io_fptr_finalize((struct rb_io *)fptr);
1175}
1176
1177static inline void
1178make_io_zombie(void *objspace, VALUE obj)
1179{
1180 rb_io_t *fptr = RFILE(obj)->fptr;
1181 rb_gc_impl_make_zombie(objspace, obj, io_fptr_finalize, fptr);
1182}
1183
1184static bool
1185rb_data_free(void *objspace, VALUE obj)
1186{
1187 bool typed = RTYPEDDATA_P(obj);
1188 void *data = typed ? RTYPEDDATA_GET_DATA(obj) : DATA_PTR(obj);
1189 if (data) {
1190 int free_immediately = false;
1191 bool embedded = false;
1192 bool free_embeddable_data = false;
1193 void (*dfree)(void *);
1194
1195 if (typed) {
1196 const rb_data_type_t *type = RTYPEDDATA_TYPE(obj);
1197 dfree = type->function.dfree;
1198 if (dfree) {
1199 embedded = RTYPEDDATA_EMBEDDED_P(obj);
1200 free_immediately = (type->flags & RUBY_TYPED_FREE_IMMEDIATELY) != 0;
1201 free_embeddable_data = (type->flags & RUBY_TYPED_EMBEDDABLE) && !embedded;
1202 }
1203 }
1204 else {
1205 dfree = RDATA(obj)->dfree;
1206 }
1207
1208 if (dfree) {
1209 if (dfree == RUBY_DEFAULT_FREE) {
1210 if (!typed || !embedded) {
1211 xfree(data);
1212 RB_DEBUG_COUNTER_INC(obj_data_xfree);
1213 }
1214 }
1215 else if (free_immediately) {
1216 (*dfree)(data);
1217 if (free_embeddable_data) {
1218 xfree(data);
1219 }
1220
1221 RB_DEBUG_COUNTER_INC(obj_data_imm_free);
1222 }
1223 else {
1224 rb_gc_impl_make_zombie(objspace, obj, dfree, data);
1225 RB_DEBUG_COUNTER_INC(obj_data_zombie);
1226 return FALSE;
1227 }
1228 }
1229 else {
1230 RB_DEBUG_COUNTER_INC(obj_data_empty);
1231 }
1232 }
1233
1234 return true;
1235}
1236
1238 VALUE klass;
1239 rb_objspace_t *objspace; // used for update_*
1240};
1241
1242static void
1243classext_free(rb_classext_t *ext, bool is_prime, VALUE box_value, void *arg)
1244{
1245 struct classext_foreach_args *args = (struct classext_foreach_args *)arg;
1246
1247 rb_class_classext_free(args->klass, ext, is_prime);
1248}
1249
1250static void
1251classext_iclass_free(rb_classext_t *ext, bool is_prime, VALUE box_value, void *arg)
1252{
1253 struct classext_foreach_args *args = (struct classext_foreach_args *)arg;
1254
1255 rb_iclass_classext_free(args->klass, ext, is_prime);
1256}
1257
1258bool
1259rb_gc_obj_free(void *objspace, VALUE obj)
1260{
1261 struct classext_foreach_args args;
1262
1263 RB_DEBUG_COUNTER_INC(obj_free);
1264
1265 switch (BUILTIN_TYPE(obj)) {
1266 case T_NIL:
1267 case T_FIXNUM:
1268 case T_TRUE:
1269 case T_FALSE:
1270 rb_bug("obj_free() called for broken object");
1271 break;
1272 default:
1273 break;
1274 }
1275
1276 switch (BUILTIN_TYPE(obj)) {
1277 case T_OBJECT:
1278 if (FL_TEST_RAW(obj, ROBJECT_HEAP)) {
1279 if (rb_shape_obj_too_complex_p(obj)) {
1280 RB_DEBUG_COUNTER_INC(obj_obj_too_complex);
1281 st_free_table(ROBJECT_FIELDS_HASH(obj));
1282 }
1283 else {
1284 xfree(ROBJECT(obj)->as.heap.fields);
1285 RB_DEBUG_COUNTER_INC(obj_obj_ptr);
1286 }
1287 }
1288 else {
1289 RB_DEBUG_COUNTER_INC(obj_obj_embed);
1290 }
1291 break;
1292 case T_MODULE:
1293 case T_CLASS:
1294#if USE_ZJIT
1295 rb_zjit_klass_free(obj);
1296#endif
1297 args.klass = obj;
1298 rb_class_classext_foreach(obj, classext_free, (void *)&args);
1299 if (RCLASS_CLASSEXT_TBL(obj)) {
1300 st_free_table(RCLASS_CLASSEXT_TBL(obj));
1301 }
1302 (void)RB_DEBUG_COUNTER_INC_IF(obj_module_ptr, BUILTIN_TYPE(obj) == T_MODULE);
1303 (void)RB_DEBUG_COUNTER_INC_IF(obj_class_ptr, BUILTIN_TYPE(obj) == T_CLASS);
1304 break;
1305 case T_STRING:
1306 rb_str_free(obj);
1307 break;
1308 case T_ARRAY:
1309 rb_ary_free(obj);
1310 break;
1311 case T_HASH:
1312#if USE_DEBUG_COUNTER
1313 switch (RHASH_SIZE(obj)) {
1314 case 0:
1315 RB_DEBUG_COUNTER_INC(obj_hash_empty);
1316 break;
1317 case 1:
1318 RB_DEBUG_COUNTER_INC(obj_hash_1);
1319 break;
1320 case 2:
1321 RB_DEBUG_COUNTER_INC(obj_hash_2);
1322 break;
1323 case 3:
1324 RB_DEBUG_COUNTER_INC(obj_hash_3);
1325 break;
1326 case 4:
1327 RB_DEBUG_COUNTER_INC(obj_hash_4);
1328 break;
1329 case 5:
1330 case 6:
1331 case 7:
1332 case 8:
1333 RB_DEBUG_COUNTER_INC(obj_hash_5_8);
1334 break;
1335 default:
1336 GC_ASSERT(RHASH_SIZE(obj) > 8);
1337 RB_DEBUG_COUNTER_INC(obj_hash_g8);
1338 }
1339
1340 if (RHASH_AR_TABLE_P(obj)) {
1341 if (RHASH_AR_TABLE(obj) == NULL) {
1342 RB_DEBUG_COUNTER_INC(obj_hash_null);
1343 }
1344 else {
1345 RB_DEBUG_COUNTER_INC(obj_hash_ar);
1346 }
1347 }
1348 else {
1349 RB_DEBUG_COUNTER_INC(obj_hash_st);
1350 }
1351#endif
1352
1353 rb_hash_free(obj);
1354 break;
1355 case T_REGEXP:
1356 if (RREGEXP(obj)->ptr) {
1357 onig_free(RREGEXP(obj)->ptr);
1358 RB_DEBUG_COUNTER_INC(obj_regexp_ptr);
1359 }
1360 break;
1361 case T_DATA:
1362 if (!rb_data_free(objspace, obj)) return false;
1363 break;
1364 case T_MATCH:
1365 {
1366 rb_matchext_t *rm = RMATCH_EXT(obj);
1367#if USE_DEBUG_COUNTER
1368 if (rm->regs.num_regs >= 8) {
1369 RB_DEBUG_COUNTER_INC(obj_match_ge8);
1370 }
1371 else if (rm->regs.num_regs >= 4) {
1372 RB_DEBUG_COUNTER_INC(obj_match_ge4);
1373 }
1374 else if (rm->regs.num_regs >= 1) {
1375 RB_DEBUG_COUNTER_INC(obj_match_under4);
1376 }
1377#endif
1378 onig_region_free(&rm->regs, 0);
1379 xfree(rm->char_offset);
1380
1381 RB_DEBUG_COUNTER_INC(obj_match_ptr);
1382 }
1383 break;
1384 case T_FILE:
1385 if (RFILE(obj)->fptr) {
1386 make_io_zombie(objspace, obj);
1387 RB_DEBUG_COUNTER_INC(obj_file_ptr);
1388 return FALSE;
1389 }
1390 break;
1391 case T_RATIONAL:
1392 RB_DEBUG_COUNTER_INC(obj_rational);
1393 break;
1394 case T_COMPLEX:
1395 RB_DEBUG_COUNTER_INC(obj_complex);
1396 break;
1397 case T_MOVED:
1398 break;
1399 case T_ICLASS:
1400 args.klass = obj;
1401
1402 rb_class_classext_foreach(obj, classext_iclass_free, (void *)&args);
1403 if (RCLASS_CLASSEXT_TBL(obj)) {
1404 st_free_table(RCLASS_CLASSEXT_TBL(obj));
1405 }
1406
1407 RB_DEBUG_COUNTER_INC(obj_iclass_ptr);
1408 break;
1409
1410 case T_FLOAT:
1411 RB_DEBUG_COUNTER_INC(obj_float);
1412 break;
1413
1414 case T_BIGNUM:
1415 if (!BIGNUM_EMBED_P(obj) && BIGNUM_DIGITS(obj)) {
1416 xfree(BIGNUM_DIGITS(obj));
1417 RB_DEBUG_COUNTER_INC(obj_bignum_ptr);
1418 }
1419 else {
1420 RB_DEBUG_COUNTER_INC(obj_bignum_embed);
1421 }
1422 break;
1423
1424 case T_NODE:
1425 UNEXPECTED_NODE(obj_free);
1426 break;
1427
1428 case T_STRUCT:
1429 if ((RBASIC(obj)->flags & RSTRUCT_EMBED_LEN_MASK) ||
1430 RSTRUCT(obj)->as.heap.ptr == NULL) {
1431 RB_DEBUG_COUNTER_INC(obj_struct_embed);
1432 }
1433 else {
1434 xfree((void *)RSTRUCT(obj)->as.heap.ptr);
1435 RB_DEBUG_COUNTER_INC(obj_struct_ptr);
1436 }
1437 break;
1438
1439 case T_SYMBOL:
1440 RB_DEBUG_COUNTER_INC(obj_symbol);
1441 break;
1442
1443 case T_IMEMO:
1444 rb_imemo_free((VALUE)obj);
1445 break;
1446
1447 default:
1448 rb_bug("gc_sweep(): unknown data type 0x%x(%p) 0x%"PRIxVALUE,
1449 BUILTIN_TYPE(obj), (void*)obj, RBASIC(obj)->flags);
1450 }
1451
1452 if (FL_TEST_RAW(obj, FL_FINALIZE)) {
1453 rb_gc_impl_make_zombie(objspace, obj, 0, 0);
1454 return FALSE;
1455 }
1456 else {
1457 return TRUE;
1458 }
1459}
1460
1461void
1462rb_objspace_set_event_hook(const rb_event_flag_t event)
1463{
1464 rb_gc_impl_set_event_hook(rb_gc_get_objspace(), event);
1465}
1466
1467static int
1468internal_object_p(VALUE obj)
1469{
1470 void *ptr = asan_unpoison_object_temporary(obj);
1471
1472 if (RBASIC(obj)->flags) {
1473 switch (BUILTIN_TYPE(obj)) {
1474 case T_NODE:
1475 UNEXPECTED_NODE(internal_object_p);
1476 break;
1477 case T_NONE:
1478 case T_MOVED:
1479 case T_IMEMO:
1480 case T_ICLASS:
1481 case T_ZOMBIE:
1482 break;
1483 case T_CLASS:
1484 if (obj == rb_mRubyVMFrozenCore)
1485 return 1;
1486
1487 if (!RBASIC_CLASS(obj)) break;
1488 if (RCLASS_SINGLETON_P(obj)) {
1489 return rb_singleton_class_internal_p(obj);
1490 }
1491 return 0;
1492 default:
1493 if (!RBASIC(obj)->klass) break;
1494 return 0;
1495 }
1496 }
1497 if (ptr || !RBASIC(obj)->flags) {
1498 rb_asan_poison_object(obj);
1499 }
1500 return 1;
1501}
1502
1503int
1504rb_objspace_internal_object_p(VALUE obj)
1505{
1506 return internal_object_p(obj);
1507}
1508
1510 size_t num;
1511 VALUE of;
1512};
1513
1514static int
1515os_obj_of_i(void *vstart, void *vend, size_t stride, void *data)
1516{
1517 struct os_each_struct *oes = (struct os_each_struct *)data;
1518
1519 VALUE v = (VALUE)vstart;
1520 for (; v != (VALUE)vend; v += stride) {
1521 if (!internal_object_p(v)) {
1522 if (!oes->of || rb_obj_is_kind_of(v, oes->of)) {
1523 if (!rb_multi_ractor_p() || rb_ractor_shareable_p(v)) {
1524 rb_yield(v);
1525 oes->num++;
1526 }
1527 }
1528 }
1529 }
1530
1531 return 0;
1532}
1533
1534static VALUE
1535os_obj_of(VALUE of)
1536{
1537 struct os_each_struct oes;
1538
1539 oes.num = 0;
1540 oes.of = of;
1541 rb_objspace_each_objects(os_obj_of_i, &oes);
1542 return SIZET2NUM(oes.num);
1543}
1544
1545/*
1546 * call-seq:
1547 * ObjectSpace.each_object([module]) {|obj| ... } -> integer
1548 * ObjectSpace.each_object([module]) -> an_enumerator
1549 *
1550 * Calls the block once for each living, nonimmediate object in this
1551 * Ruby process. If <i>module</i> is specified, calls the block
1552 * for only those classes or modules that match (or are a subclass of)
1553 * <i>module</i>. Returns the number of objects found. Immediate
1554 * objects (such as <code>Fixnum</code>s, static <code>Symbol</code>s
1555 * <code>true</code>, <code>false</code> and <code>nil</code>) are
1556 * never returned.
1557 *
1558 * If no block is given, an enumerator is returned instead.
1559 *
1560 * Job = Class.new
1561 * jobs = [Job.new, Job.new]
1562 * count = ObjectSpace.each_object(Job) {|x| p x }
1563 * puts "Total count: #{count}"
1564 *
1565 * <em>produces:</em>
1566 *
1567 * #<Job:0x000000011d6cbbf0>
1568 * #<Job:0x000000011d6cbc68>
1569 * Total count: 2
1570 *
1571 * Due to a current Ractor implementation issue, this method does not yield
1572 * Ractor-unshareable objects when the process is in multi-Ractor mode. Multi-ractor
1573 * mode is enabled when <code>Ractor.new</code> has been called for the first time.
1574 * See https://bugs.ruby-lang.org/issues/19387 for more information.
1575 *
1576 * a = 12345678987654321 # shareable
1577 * b = [].freeze # shareable
1578 * c = {} # not shareable
1579 * ObjectSpace.each_object {|x| x } # yields a, b, and c
1580 * Ractor.new {} # enter multi-Ractor mode
1581 * ObjectSpace.each_object {|x| x } # does not yield c
1582 *
1583 */
1584
1585static VALUE
1586os_each_obj(int argc, VALUE *argv, VALUE os)
1587{
1588 VALUE of;
1589
1590 of = (!rb_check_arity(argc, 0, 1) ? 0 : argv[0]);
1591 RETURN_ENUMERATOR(os, 1, &of);
1592 return os_obj_of(of);
1593}
1594
1595/*
1596 * call-seq:
1597 * ObjectSpace.undefine_finalizer(obj)
1598 *
1599 * Removes all finalizers for <i>obj</i>.
1600 *
1601 */
1602
1603static VALUE
1604undefine_final(VALUE os, VALUE obj)
1605{
1606 return rb_undefine_finalizer(obj);
1607}
1608
1609VALUE
1610rb_undefine_finalizer(VALUE obj)
1611{
1612 rb_check_frozen(obj);
1613
1614 rb_gc_impl_undefine_finalizer(rb_gc_get_objspace(), obj);
1615
1616 return obj;
1617}
1618
1619static void
1620should_be_callable(VALUE block)
1621{
1622 if (!rb_obj_respond_to(block, idCall, TRUE)) {
1623 rb_raise(rb_eArgError, "wrong type argument %"PRIsVALUE" (should be callable)",
1624 rb_obj_class(block));
1625 }
1626}
1627
1628static void
1629should_be_finalizable(VALUE obj)
1630{
1631 if (!FL_ABLE(obj)) {
1632 rb_raise(rb_eArgError, "cannot define finalizer for %s",
1633 rb_obj_classname(obj));
1634 }
1635 rb_check_frozen(obj);
1636}
1637
1638void
1639rb_gc_copy_finalizer(VALUE dest, VALUE obj)
1640{
1641 rb_gc_impl_copy_finalizer(rb_gc_get_objspace(), dest, obj);
1642}
1643
1644/*
1645 * call-seq:
1646 * ObjectSpace.define_finalizer(obj, aProc=proc())
1647 *
1648 * Adds <i>aProc</i> as a finalizer, to be called after <i>obj</i>
1649 * was destroyed. The object ID of the <i>obj</i> will be passed
1650 * as an argument to <i>aProc</i>. If <i>aProc</i> is a lambda or
1651 * method, make sure it can be called with a single argument.
1652 *
1653 * The return value is an array <code>[0, aProc]</code>.
1654 *
1655 * The two recommended patterns are to either create the finaliser proc
1656 * in a non-instance method where it can safely capture the needed state,
1657 * or to use a custom callable object that stores the needed state
1658 * explicitly as instance variables.
1659 *
1660 * class Foo
1661 * def initialize(data_needed_for_finalization)
1662 * ObjectSpace.define_finalizer(self, self.class.create_finalizer(data_needed_for_finalization))
1663 * end
1664 *
1665 * def self.create_finalizer(data_needed_for_finalization)
1666 * proc {
1667 * puts "finalizing #{data_needed_for_finalization}"
1668 * }
1669 * end
1670 * end
1671 *
1672 * class Bar
1673 * class Remover
1674 * def initialize(data_needed_for_finalization)
1675 * @data_needed_for_finalization = data_needed_for_finalization
1676 * end
1677 *
1678 * def call(id)
1679 * puts "finalizing #{@data_needed_for_finalization}"
1680 * end
1681 * end
1682 *
1683 * def initialize(data_needed_for_finalization)
1684 * ObjectSpace.define_finalizer(self, Remover.new(data_needed_for_finalization))
1685 * end
1686 * end
1687 *
1688 * Note that if your finalizer references the object to be
1689 * finalized it will never be run on GC, although it will still be
1690 * run at exit. You will get a warning if you capture the object
1691 * to be finalized as the receiver of the finalizer.
1692 *
1693 * class CapturesSelf
1694 * def initialize(name)
1695 * ObjectSpace.define_finalizer(self, proc {
1696 * # this finalizer will only be run on exit
1697 * puts "finalizing #{name}"
1698 * })
1699 * end
1700 * end
1701 *
1702 * Also note that finalization can be unpredictable and is never guaranteed
1703 * to be run except on exit.
1704 */
1705
1706static VALUE
1707define_final(int argc, VALUE *argv, VALUE os)
1708{
1709 VALUE obj, block;
1710
1711 rb_scan_args(argc, argv, "11", &obj, &block);
1712 if (argc == 1) {
1713 block = rb_block_proc();
1714 }
1715
1716 if (rb_callable_receiver(block) == obj) {
1717 rb_warn("finalizer references object to be finalized");
1718 }
1719
1720 return rb_define_finalizer(obj, block);
1721}
1722
1723VALUE
1724rb_define_finalizer(VALUE obj, VALUE block)
1725{
1726 should_be_finalizable(obj);
1727 should_be_callable(block);
1728
1729 block = rb_gc_impl_define_finalizer(rb_gc_get_objspace(), obj, block);
1730
1731 block = rb_ary_new3(2, INT2FIX(0), block);
1732 OBJ_FREEZE(block);
1733 return block;
1734}
1735
1736void
1737rb_objspace_call_finalizer(void)
1738{
1739 rb_gc_impl_shutdown_call_finalizer(rb_gc_get_objspace());
1740}
1741
1742void
1743rb_objspace_free_objects(void *objspace)
1744{
1745 rb_gc_impl_shutdown_free_objects(objspace);
1746}
1747
1748int
1749rb_objspace_garbage_object_p(VALUE obj)
1750{
1751 return !SPECIAL_CONST_P(obj) && rb_gc_impl_garbage_object_p(rb_gc_get_objspace(), obj);
1752}
1753
1754bool
1755rb_gc_pointer_to_heap_p(VALUE obj)
1756{
1757 return rb_gc_impl_pointer_to_heap_p(rb_gc_get_objspace(), (void *)obj);
1758}
1759
1760#define OBJ_ID_INCREMENT (RUBY_IMMEDIATE_MASK + 1)
1761#define LAST_OBJECT_ID() (object_id_counter * OBJ_ID_INCREMENT)
1762static VALUE id2ref_value = 0;
1763static st_table *id2ref_tbl = NULL;
1764
1765#if SIZEOF_SIZE_T == SIZEOF_LONG_LONG
1766static size_t object_id_counter = 1;
1767#else
1768static unsigned long long object_id_counter = 1;
1769#endif
1770
1771static inline VALUE
1772generate_next_object_id(void)
1773{
1774#if SIZEOF_SIZE_T == SIZEOF_LONG_LONG
1775 // 64bit atomics are available
1776 return SIZET2NUM(RUBY_ATOMIC_SIZE_FETCH_ADD(object_id_counter, 1) * OBJ_ID_INCREMENT);
1777#else
1778 unsigned int lock_lev = RB_GC_VM_LOCK();
1779 VALUE id = ULL2NUM(++object_id_counter * OBJ_ID_INCREMENT);
1780 RB_GC_VM_UNLOCK(lock_lev);
1781 return id;
1782#endif
1783}
1784
1785void
1786rb_gc_obj_id_moved(VALUE obj)
1787{
1788 if (UNLIKELY(id2ref_tbl)) {
1789 st_insert(id2ref_tbl, (st_data_t)rb_obj_id(obj), (st_data_t)obj);
1790 }
1791}
1792
1793static int
1794object_id_cmp(st_data_t x, st_data_t y)
1795{
1796 if (RB_TYPE_P(x, T_BIGNUM)) {
1797 return !rb_big_eql(x, y);
1798 }
1799 else {
1800 return x != y;
1801 }
1802}
1803
1804static st_index_t
1805object_id_hash(st_data_t n)
1806{
1807 return FIX2LONG(rb_hash((VALUE)n));
1808}
1809
1810static const struct st_hash_type object_id_hash_type = {
1811 object_id_cmp,
1812 object_id_hash,
1813};
1814
1815static void gc_mark_tbl_no_pin(st_table *table);
1816
1817static void
1818id2ref_tbl_mark(void *data)
1819{
1820 st_table *table = (st_table *)data;
1821 if (UNLIKELY(!RB_POSFIXABLE(LAST_OBJECT_ID()))) {
1822 // It's very unlikely, but if enough object ids were generated, keys may be T_BIGNUM
1823 rb_mark_set(table);
1824 }
1825 // We purposely don't mark values, as they are weak references.
1826 // rb_gc_obj_free_vm_weak_references takes care of cleaning them up.
1827}
1828
1829static size_t
1830id2ref_tbl_memsize(const void *data)
1831{
1832 return rb_st_memsize(data);
1833}
1834
1835static void
1836id2ref_tbl_free(void *data)
1837{
1838 id2ref_tbl = NULL; // clear global ref
1839 st_table *table = (st_table *)data;
1840 st_free_table(table);
1841}
1842
1843static const rb_data_type_t id2ref_tbl_type = {
1844 .wrap_struct_name = "VM/_id2ref_table",
1845 .function = {
1846 .dmark = id2ref_tbl_mark,
1847 .dfree = id2ref_tbl_free,
1848 .dsize = id2ref_tbl_memsize,
1849 // dcompact function not required because the table is reference updated
1850 // in rb_gc_vm_weak_table_foreach
1851 },
1852 .flags = RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_FREE_IMMEDIATELY
1853};
1854
1855static VALUE
1856class_object_id(VALUE klass)
1857{
1858 VALUE id = RUBY_ATOMIC_VALUE_LOAD(RCLASS(klass)->object_id);
1859 if (!id) {
1860 unsigned int lock_lev = RB_GC_VM_LOCK();
1861 id = generate_next_object_id();
1862 VALUE existing_id = RUBY_ATOMIC_VALUE_CAS(RCLASS(klass)->object_id, 0, id);
1863 if (existing_id) {
1864 id = existing_id;
1865 }
1866 else if (RB_UNLIKELY(id2ref_tbl)) {
1867 st_insert(id2ref_tbl, id, klass);
1868 }
1869 RB_GC_VM_UNLOCK(lock_lev);
1870 }
1871 return id;
1872}
1873
1874static inline VALUE
1875object_id_get(VALUE obj, shape_id_t shape_id)
1876{
1877 VALUE id;
1878 if (rb_shape_too_complex_p(shape_id)) {
1879 id = rb_obj_field_get(obj, ROOT_TOO_COMPLEX_WITH_OBJ_ID);
1880 }
1881 else {
1882 id = rb_obj_field_get(obj, rb_shape_object_id(shape_id));
1883 }
1884
1885#if RUBY_DEBUG
1886 if (!(FIXNUM_P(id) || RB_TYPE_P(id, T_BIGNUM))) {
1887 rb_p(obj);
1888 rb_bug("Object's shape includes object_id, but it's missing %s", rb_obj_info(obj));
1889 }
1890#endif
1891
1892 return id;
1893}
1894
1895static VALUE
1896object_id0(VALUE obj)
1897{
1898 VALUE id = Qfalse;
1899 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1900
1901 if (rb_shape_has_object_id(shape_id)) {
1902 return object_id_get(obj, shape_id);
1903 }
1904
1905 shape_id_t object_id_shape_id = rb_shape_transition_object_id(obj);
1906
1907 id = generate_next_object_id();
1908 rb_obj_field_set(obj, object_id_shape_id, 0, id);
1909
1910 RUBY_ASSERT(RBASIC_SHAPE_ID(obj) == object_id_shape_id);
1911 RUBY_ASSERT(rb_shape_obj_has_id(obj));
1912
1913 if (RB_UNLIKELY(id2ref_tbl)) {
1914 RB_VM_LOCKING() {
1915 st_insert(id2ref_tbl, (st_data_t)id, (st_data_t)obj);
1916 }
1917 }
1918 return id;
1919}
1920
1921static VALUE
1922object_id(VALUE obj)
1923{
1924 switch (BUILTIN_TYPE(obj)) {
1925 case T_CLASS:
1926 case T_MODULE:
1927 // With Ruby Box, classes and modules have different fields
1928 // in different boxes, so we cannot store the object id
1929 // in fields.
1930 return class_object_id(obj);
1931 case T_IMEMO:
1932 RUBY_ASSERT(IMEMO_TYPE_P(obj, imemo_fields));
1933 break;
1934 default:
1935 break;
1936 }
1937
1938 if (UNLIKELY(rb_gc_multi_ractor_p() && rb_ractor_shareable_p(obj))) {
1939 unsigned int lock_lev = RB_GC_VM_LOCK();
1940 VALUE id = object_id0(obj);
1941 RB_GC_VM_UNLOCK(lock_lev);
1942 return id;
1943 }
1944
1945 return object_id0(obj);
1946}
1947
1948static void
1949build_id2ref_i(VALUE obj, void *data)
1950{
1951 st_table *id2ref_tbl = (st_table *)data;
1952
1953 switch (BUILTIN_TYPE(obj)) {
1954 case T_CLASS:
1955 case T_MODULE:
1956 RUBY_ASSERT(!rb_objspace_garbage_object_p(obj));
1957 if (RCLASS(obj)->object_id) {
1958 st_insert(id2ref_tbl, RCLASS(obj)->object_id, obj);
1959 }
1960 break;
1961 case T_IMEMO:
1962 RUBY_ASSERT(!rb_objspace_garbage_object_p(obj));
1963 if (IMEMO_TYPE_P(obj, imemo_fields) && rb_shape_obj_has_id(obj)) {
1964 st_insert(id2ref_tbl, rb_obj_id(obj), rb_imemo_fields_owner(obj));
1965 }
1966 break;
1967 case T_OBJECT:
1968 RUBY_ASSERT(!rb_objspace_garbage_object_p(obj));
1969 if (rb_shape_obj_has_id(obj)) {
1970 st_insert(id2ref_tbl, rb_obj_id(obj), obj);
1971 }
1972 break;
1973 default:
1974 // For generic_fields, the T_IMEMO/fields is responsible for populating the entry.
1975 break;
1976 }
1977}
1978
1979static VALUE
1980object_id_to_ref(void *objspace_ptr, VALUE object_id)
1981{
1982 rb_objspace_t *objspace = objspace_ptr;
1983
1984 unsigned int lev = RB_GC_VM_LOCK();
1985
1986 if (!id2ref_tbl) {
1987 rb_gc_vm_barrier(); // stop other ractors
1988
1989 // GC Must not trigger while we build the table, otherwise if we end
1990 // up freeing an object that had an ID, we might try to delete it from
1991 // the table even though it wasn't inserted yet.
1992 st_table *tmp_id2ref_tbl = st_init_table(&object_id_hash_type);
1993 VALUE tmp_id2ref_value = TypedData_Wrap_Struct(0, &id2ref_tbl_type, tmp_id2ref_tbl);
1994
1995 // build_id2ref_i will most certainly malloc, which could trigger GC and sweep
1996 // objects we just added to the table.
1997 // By calling rb_gc_disable() we also save having to handle potentially garbage objects.
1998 bool gc_disabled = RTEST(rb_gc_disable());
1999 {
2000 id2ref_tbl = tmp_id2ref_tbl;
2001 id2ref_value = tmp_id2ref_value;
2002
2003 rb_gc_impl_each_object(objspace, build_id2ref_i, (void *)id2ref_tbl);
2004 }
2005 if (!gc_disabled) rb_gc_enable();
2006 }
2007
2008 VALUE obj;
2009 bool found = st_lookup(id2ref_tbl, object_id, &obj) && !rb_gc_impl_garbage_object_p(objspace, obj);
2010
2011 RB_GC_VM_UNLOCK(lev);
2012
2013 if (found) {
2014 return obj;
2015 }
2016
2017 if (rb_funcall(object_id, rb_intern(">="), 1, ULL2NUM(LAST_OBJECT_ID()))) {
2018 rb_raise(rb_eRangeError, "%"PRIsVALUE" is not an id value", object_id);
2019 }
2020 else {
2021 rb_raise(rb_eRangeError, "%"PRIsVALUE" is a recycled object", object_id);
2022 }
2023}
2024
2025static inline void
2026obj_free_object_id(VALUE obj)
2027{
2028 VALUE obj_id = 0;
2029 if (RB_UNLIKELY(id2ref_tbl)) {
2030 switch (BUILTIN_TYPE(obj)) {
2031 case T_CLASS:
2032 case T_MODULE:
2033 obj_id = RCLASS(obj)->object_id;
2034 break;
2035 case T_IMEMO:
2036 if (!IMEMO_TYPE_P(obj, imemo_fields)) {
2037 return;
2038 }
2039 // fallthrough
2040 case T_OBJECT:
2041 {
2042 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
2043 if (rb_shape_has_object_id(shape_id)) {
2044 obj_id = object_id_get(obj, shape_id);
2045 }
2046 break;
2047 }
2048 default:
2049 // For generic_fields, the T_IMEMO/fields is responsible for freeing the id.
2050 return;
2051 }
2052
2053 if (RB_UNLIKELY(obj_id)) {
2054 RUBY_ASSERT(FIXNUM_P(obj_id) || RB_TYPE_P(obj_id, T_BIGNUM));
2055
2056 if (!st_delete(id2ref_tbl, (st_data_t *)&obj_id, NULL)) {
2057 // The the object is a T_IMEMO/fields, then it's possible the actual object
2058 // has been garbage collected already.
2059 if (!RB_TYPE_P(obj, T_IMEMO)) {
2060 rb_bug("Object ID seen, but not in _id2ref table: object_id=%llu object=%s", NUM2ULL(obj_id), rb_obj_info(obj));
2061 }
2062 }
2063 }
2064 }
2065}
2066
2067void
2068rb_gc_obj_free_vm_weak_references(VALUE obj)
2069{
2070 ASSUME(!RB_SPECIAL_CONST_P(obj));
2071 obj_free_object_id(obj);
2072
2073 if (rb_obj_gen_fields_p(obj)) {
2075 }
2076
2077 switch (BUILTIN_TYPE(obj)) {
2078 case T_STRING:
2079 if (FL_TEST_RAW(obj, RSTRING_FSTR)) {
2080 rb_gc_free_fstring(obj);
2081 }
2082 break;
2083 case T_SYMBOL:
2084 rb_gc_free_dsymbol(obj);
2085 break;
2086 case T_IMEMO:
2087 switch (imemo_type(obj)) {
2088 case imemo_callcache: {
2089 const struct rb_callcache *cc = (const struct rb_callcache *)obj;
2090
2091 if (vm_cc_refinement_p(cc)) {
2092 rb_vm_delete_cc_refinement(cc);
2093 }
2094
2095 break;
2096 }
2097 case imemo_callinfo:
2098 rb_vm_ci_free((const struct rb_callinfo *)obj);
2099 break;
2100 case imemo_ment:
2101 rb_free_method_entry_vm_weak_references((const rb_method_entry_t *)obj);
2102 break;
2103 default:
2104 break;
2105 }
2106 break;
2107 default:
2108 break;
2109 }
2110}
2111
2112/*
2113 * call-seq:
2114 * ObjectSpace._id2ref(object_id) -> an_object
2115 *
2116 * Converts an object id to a reference to the object. May not be
2117 * called on an object id passed as a parameter to a finalizer.
2118 *
2119 * s = "I am a string" #=> "I am a string"
2120 * r = ObjectSpace._id2ref(s.object_id) #=> "I am a string"
2121 * r == s #=> true
2122 *
2123 * On multi-ractor mode, if the object is not shareable, it raises
2124 * RangeError.
2125 *
2126 * This method is deprecated and should no longer be used.
2127 */
2128
2129static VALUE
2130id2ref(VALUE objid)
2131{
2132 objid = rb_to_int(objid);
2133 if (FIXNUM_P(objid) || rb_big_size(objid) <= SIZEOF_VOIDP) {
2134 VALUE ptr = (VALUE)NUM2PTR(objid);
2135 if (SPECIAL_CONST_P(ptr)) {
2136 if (ptr == Qtrue) return Qtrue;
2137 if (ptr == Qfalse) return Qfalse;
2138 if (NIL_P(ptr)) return Qnil;
2139 if (FIXNUM_P(ptr)) return ptr;
2140 if (FLONUM_P(ptr)) return ptr;
2141
2142 if (SYMBOL_P(ptr)) {
2143 // Check that the symbol is valid
2144 if (rb_static_id_valid_p(SYM2ID(ptr))) {
2145 return ptr;
2146 }
2147 else {
2148 rb_raise(rb_eRangeError, "%p is not a symbol id value", (void *)ptr);
2149 }
2150 }
2151
2152 rb_raise(rb_eRangeError, "%"PRIsVALUE" is not an id value", objid);
2153 }
2154 }
2155
2156 VALUE obj = object_id_to_ref(rb_gc_get_objspace(), objid);
2157 if (!rb_multi_ractor_p() || rb_ractor_shareable_p(obj)) {
2158 return obj;
2159 }
2160 else {
2161 rb_raise(rb_eRangeError, "%"PRIsVALUE" is the id of an unshareable object on multi-ractor", objid);
2162 }
2163}
2164
2165/* :nodoc: */
2166static VALUE
2167os_id2ref(VALUE os, VALUE objid)
2168{
2169 rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "ObjectSpace._id2ref is deprecated");
2170 return id2ref(objid);
2171}
2172
2173static VALUE
2174rb_find_object_id(void *objspace, VALUE obj, VALUE (*get_heap_object_id)(VALUE))
2175{
2176 if (SPECIAL_CONST_P(obj)) {
2177#if SIZEOF_LONG == SIZEOF_VOIDP
2178 return LONG2NUM((SIGNED_VALUE)obj);
2179#else
2180 return LL2NUM((SIGNED_VALUE)obj);
2181#endif
2182 }
2183
2184 return get_heap_object_id(obj);
2185}
2186
2187static VALUE
2188nonspecial_obj_id(VALUE obj)
2189{
2190#if SIZEOF_LONG == SIZEOF_VOIDP
2191 return (VALUE)((SIGNED_VALUE)(obj)|FIXNUM_FLAG);
2192#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
2193 return LL2NUM((SIGNED_VALUE)(obj) / 2);
2194#else
2195# error not supported
2196#endif
2197}
2198
2199VALUE
2200rb_memory_id(VALUE obj)
2201{
2202 return rb_find_object_id(NULL, obj, nonspecial_obj_id);
2203}
2204
2205/*
2206 * Document-method: __id__
2207 * Document-method: object_id
2208 *
2209 * call-seq:
2210 * obj.__id__ -> integer
2211 * obj.object_id -> integer
2212 *
2213 * Returns an integer identifier for +obj+.
2214 *
2215 * The same number will be returned on all calls to +object_id+ for a given
2216 * object, and no two active objects will share an id.
2217 *
2218 * Note: that some objects of builtin classes are reused for optimization.
2219 * This is the case for immediate values and frozen string literals.
2220 *
2221 * BasicObject implements +__id__+, Kernel implements +object_id+.
2222 *
2223 * Immediate values are not passed by reference but are passed by value:
2224 * +nil+, +true+, +false+, Fixnums, Symbols, and some Floats.
2225 *
2226 * Object.new.object_id == Object.new.object_id # => false
2227 * (21 * 2).object_id == (21 * 2).object_id # => true
2228 * "hello".object_id == "hello".object_id # => false
2229 * "hi".freeze.object_id == "hi".freeze.object_id # => true
2230 */
2231
2232VALUE
2233rb_obj_id(VALUE obj)
2234{
2235 /* If obj is an immediate, the object ID is obj directly converted to a Numeric.
2236 * Otherwise, the object ID is a Numeric that is a non-zero multiple of
2237 * (RUBY_IMMEDIATE_MASK + 1) which guarantees that it does not collide with
2238 * any immediates. */
2239 return rb_find_object_id(rb_gc_get_objspace(), obj, object_id);
2240}
2241
2242bool
2243rb_obj_id_p(VALUE obj)
2244{
2245 return !RB_TYPE_P(obj, T_IMEMO) && rb_shape_obj_has_id(obj);
2246}
2247
2248/*
2249 * GC implementations should call this function before the GC phase that updates references
2250 * embedded in the machine code generated by JIT compilers. JIT compilers usually enforce the
2251 * "W^X" policy and protect the code memory from being modified during execution. This function
2252 * makes the code memory writeable.
2253 */
2254void
2255rb_gc_before_updating_jit_code(void)
2256{
2257#if USE_YJIT
2258 rb_yjit_mark_all_writeable();
2259#endif
2260}
2261
2262/*
2263 * GC implementations should call this function before the GC phase that updates references
2264 * embedded in the machine code generated by JIT compilers. This function makes the code memory
2265 * executable again.
2266 */
2267void
2268rb_gc_after_updating_jit_code(void)
2269{
2270#if USE_YJIT
2271 rb_yjit_mark_all_executable();
2272#endif
2273}
2274
2275static void
2276classext_memsize(rb_classext_t *ext, bool prime, VALUE box_value, void *arg)
2277{
2278 size_t *size = (size_t *)arg;
2279 size_t s = 0;
2280
2281 if (RCLASSEXT_M_TBL(ext)) {
2282 s += rb_id_table_memsize(RCLASSEXT_M_TBL(ext));
2283 }
2284 if (RCLASSEXT_CONST_TBL(ext)) {
2285 s += rb_id_table_memsize(RCLASSEXT_CONST_TBL(ext));
2286 }
2287 if (RCLASSEXT_SUPERCLASSES_WITH_SELF(ext)) {
2288 s += (RCLASSEXT_SUPERCLASS_DEPTH(ext) + 1) * sizeof(VALUE);
2289 }
2290 if (!prime) {
2291 s += sizeof(rb_classext_t);
2292 }
2293 *size += s;
2294}
2295
2296static void
2297classext_superclasses_memsize(rb_classext_t *ext, bool prime, VALUE box_value, void *arg)
2298{
2299 size_t *size = (size_t *)arg;
2300 size_t array_size;
2301 if (RCLASSEXT_SUPERCLASSES_WITH_SELF(ext)) {
2302 RUBY_ASSERT(prime);
2303 array_size = RCLASSEXT_SUPERCLASS_DEPTH(ext) + 1;
2304 *size += array_size * sizeof(VALUE);
2305 }
2306}
2307
2308size_t
2309rb_obj_memsize_of(VALUE obj)
2310{
2311 size_t size = 0;
2312
2313 if (SPECIAL_CONST_P(obj)) {
2314 return 0;
2315 }
2316
2317 switch (BUILTIN_TYPE(obj)) {
2318 case T_OBJECT:
2319 if (FL_TEST_RAW(obj, ROBJECT_HEAP)) {
2320 if (rb_shape_obj_too_complex_p(obj)) {
2321 size += rb_st_memsize(ROBJECT_FIELDS_HASH(obj));
2322 }
2323 else {
2324 size += ROBJECT_FIELDS_CAPACITY(obj) * sizeof(VALUE);
2325 }
2326 }
2327 break;
2328 case T_MODULE:
2329 case T_CLASS:
2330 rb_class_classext_foreach(obj, classext_memsize, (void *)&size);
2331 rb_class_classext_foreach(obj, classext_superclasses_memsize, (void *)&size);
2332 break;
2333 case T_ICLASS:
2334 if (RICLASS_OWNS_M_TBL_P(obj)) {
2335 if (RCLASS_M_TBL(obj)) {
2336 size += rb_id_table_memsize(RCLASS_M_TBL(obj));
2337 }
2338 }
2339 break;
2340 case T_STRING:
2341 size += rb_str_memsize(obj);
2342 break;
2343 case T_ARRAY:
2344 size += rb_ary_memsize(obj);
2345 break;
2346 case T_HASH:
2347 if (RHASH_ST_TABLE_P(obj)) {
2348 VM_ASSERT(RHASH_ST_TABLE(obj) != NULL);
2349 /* st_table is in the slot */
2350 size += st_memsize(RHASH_ST_TABLE(obj)) - sizeof(st_table);
2351 }
2352 break;
2353 case T_REGEXP:
2354 if (RREGEXP_PTR(obj)) {
2355 size += onig_memsize(RREGEXP_PTR(obj));
2356 }
2357 break;
2358 case T_DATA:
2359 size += rb_objspace_data_type_memsize(obj);
2360 break;
2361 case T_MATCH:
2362 {
2363 rb_matchext_t *rm = RMATCH_EXT(obj);
2364 size += onig_region_memsize(&rm->regs);
2365 size += sizeof(struct rmatch_offset) * rm->char_offset_num_allocated;
2366 }
2367 break;
2368 case T_FILE:
2369 if (RFILE(obj)->fptr) {
2370 size += rb_io_memsize(RFILE(obj)->fptr);
2371 }
2372 break;
2373 case T_RATIONAL:
2374 case T_COMPLEX:
2375 break;
2376 case T_IMEMO:
2377 size += rb_imemo_memsize(obj);
2378 break;
2379
2380 case T_FLOAT:
2381 case T_SYMBOL:
2382 break;
2383
2384 case T_BIGNUM:
2385 if (!(RBASIC(obj)->flags & BIGNUM_EMBED_FLAG) && BIGNUM_DIGITS(obj)) {
2386 size += BIGNUM_LEN(obj) * sizeof(BDIGIT);
2387 }
2388 break;
2389
2390 case T_NODE:
2391 UNEXPECTED_NODE(obj_memsize_of);
2392 break;
2393
2394 case T_STRUCT:
2395 if ((RBASIC(obj)->flags & RSTRUCT_EMBED_LEN_MASK) == 0 &&
2396 RSTRUCT(obj)->as.heap.ptr) {
2397 size += sizeof(VALUE) * RSTRUCT_LEN(obj);
2398 }
2399 break;
2400
2401 case T_ZOMBIE:
2402 case T_MOVED:
2403 break;
2404
2405 default:
2406 rb_bug("objspace/memsize_of(): unknown data type 0x%x(%p)",
2407 BUILTIN_TYPE(obj), (void*)obj);
2408 }
2409
2410 return size + rb_gc_obj_slot_size(obj);
2411}
2412
2413static int
2414set_zero(st_data_t key, st_data_t val, st_data_t arg)
2415{
2416 VALUE k = (VALUE)key;
2417 VALUE hash = (VALUE)arg;
2418 rb_hash_aset(hash, k, INT2FIX(0));
2419 return ST_CONTINUE;
2420}
2421
2423 size_t counts[T_MASK+1];
2424 size_t freed;
2425 size_t total;
2426};
2427
2428static void
2429count_objects_i(VALUE obj, void *d)
2430{
2431 struct count_objects_data *data = (struct count_objects_data *)d;
2432
2433 if (RBASIC(obj)->flags) {
2434 data->counts[BUILTIN_TYPE(obj)]++;
2435 }
2436 else {
2437 data->freed++;
2438 }
2439
2440 data->total++;
2441}
2442
2443/*
2444 * call-seq:
2445 * ObjectSpace.count_objects([result_hash]) -> hash
2446 *
2447 * Counts all objects grouped by type.
2448 *
2449 * It returns a hash, such as:
2450 * {
2451 * :TOTAL=>10000,
2452 * :FREE=>3011,
2453 * :T_OBJECT=>6,
2454 * :T_CLASS=>404,
2455 * # ...
2456 * }
2457 *
2458 * The contents of the returned hash are implementation specific.
2459 * It may be changed in future.
2460 *
2461 * The keys starting with +:T_+ means live objects.
2462 * For example, +:T_ARRAY+ is the number of arrays.
2463 * +:FREE+ means object slots which is not used now.
2464 * +:TOTAL+ means sum of above.
2465 *
2466 * If the optional argument +result_hash+ is given,
2467 * it is overwritten and returned. This is intended to avoid probe effect.
2468 *
2469 * h = {}
2470 * ObjectSpace.count_objects(h)
2471 * puts h
2472 * # => { :TOTAL=>10000, :T_CLASS=>158280, :T_MODULE=>20672, :T_STRING=>527249 }
2473 *
2474 * This method is only expected to work on C Ruby.
2475 *
2476 */
2477
2478static VALUE
2479count_objects(int argc, VALUE *argv, VALUE os)
2480{
2481 struct count_objects_data data = { 0 };
2482 VALUE hash = Qnil;
2483 VALUE types[T_MASK + 1];
2484
2485 if (rb_check_arity(argc, 0, 1) == 1) {
2486 hash = argv[0];
2487 if (!RB_TYPE_P(hash, T_HASH))
2488 rb_raise(rb_eTypeError, "non-hash given");
2489 }
2490
2491 for (size_t i = 0; i <= T_MASK; i++) {
2492 // type_sym can allocate an object,
2493 // so we need to create all key symbols in advance
2494 // not to disturb the result
2495 types[i] = type_sym(i);
2496 }
2497
2498 // Same as type_sym, we need to create all key symbols in advance
2499 VALUE total = ID2SYM(rb_intern("TOTAL"));
2500 VALUE free = ID2SYM(rb_intern("FREE"));
2501
2502 rb_gc_impl_each_object(rb_gc_get_objspace(), count_objects_i, &data);
2503
2504 if (NIL_P(hash)) {
2505 hash = rb_hash_new();
2506 }
2507 else if (!RHASH_EMPTY_P(hash)) {
2508 rb_hash_stlike_foreach(hash, set_zero, hash);
2509 }
2510 rb_hash_aset(hash, total, SIZET2NUM(data.total));
2511 rb_hash_aset(hash, free, SIZET2NUM(data.freed));
2512
2513 for (size_t i = 0; i <= T_MASK; i++) {
2514 if (data.counts[i]) {
2515 rb_hash_aset(hash, types[i], SIZET2NUM(data.counts[i]));
2516 }
2517 }
2518
2519 return hash;
2520}
2521
2522#define SET_STACK_END SET_MACHINE_STACK_END(&ec->machine.stack_end)
2523
2524#define STACK_START (ec->machine.stack_start)
2525#define STACK_END (ec->machine.stack_end)
2526#define STACK_LEVEL_MAX (ec->machine.stack_maxsize/sizeof(VALUE))
2527
2528#if STACK_GROW_DIRECTION < 0
2529# define STACK_LENGTH (size_t)(STACK_START - STACK_END)
2530#elif STACK_GROW_DIRECTION > 0
2531# define STACK_LENGTH (size_t)(STACK_END - STACK_START + 1)
2532#else
2533# define STACK_LENGTH ((STACK_END < STACK_START) ? (size_t)(STACK_START - STACK_END) \
2534 : (size_t)(STACK_END - STACK_START + 1))
2535#endif
2536#if !STACK_GROW_DIRECTION
2537int ruby_stack_grow_direction;
2538int
2539ruby_get_stack_grow_direction(volatile VALUE *addr)
2540{
2541 VALUE *end;
2542 SET_MACHINE_STACK_END(&end);
2543
2544 if (end > addr) return ruby_stack_grow_direction = 1;
2545 return ruby_stack_grow_direction = -1;
2546}
2547#endif
2548
2549size_t
2551{
2552 rb_execution_context_t *ec = GET_EC();
2553 SET_STACK_END;
2554 if (p) *p = STACK_UPPER(STACK_END, STACK_START, STACK_END);
2555 return STACK_LENGTH;
2556}
2557
2558#define PREVENT_STACK_OVERFLOW 1
2559#ifndef PREVENT_STACK_OVERFLOW
2560#if !(defined(POSIX_SIGNAL) && defined(SIGSEGV) && defined(HAVE_SIGALTSTACK))
2561# define PREVENT_STACK_OVERFLOW 1
2562#else
2563# define PREVENT_STACK_OVERFLOW 0
2564#endif
2565#endif
2566#if PREVENT_STACK_OVERFLOW && !defined(__EMSCRIPTEN__)
2567static int
2568stack_check(rb_execution_context_t *ec, int water_mark)
2569{
2570 SET_STACK_END;
2571
2572 size_t length = STACK_LENGTH;
2573 size_t maximum_length = STACK_LEVEL_MAX - water_mark;
2574
2575 return length > maximum_length;
2576}
2577#else
2578#define stack_check(ec, water_mark) FALSE
2579#endif
2580
2581#define STACKFRAME_FOR_CALL_CFUNC 2048
2582
2583int
2584rb_ec_stack_check(rb_execution_context_t *ec)
2585{
2586 return stack_check(ec, STACKFRAME_FOR_CALL_CFUNC);
2587}
2588
2589int
2591{
2592 return stack_check(GET_EC(), STACKFRAME_FOR_CALL_CFUNC);
2593}
2594
2595/* ==================== Marking ==================== */
2596
2597#define RB_GC_MARK_OR_TRAVERSE(func, obj_or_ptr, obj, check_obj) do { \
2598 if (!RB_SPECIAL_CONST_P(obj)) { \
2599 rb_vm_t *vm = GET_VM(); \
2600 void *objspace = vm->gc.objspace; \
2601 if (LIKELY(vm->gc.mark_func_data == NULL)) { \
2602 GC_ASSERT(rb_gc_impl_during_gc_p(objspace)); \
2603 (func)(objspace, (obj_or_ptr)); \
2604 } \
2605 else if (check_obj ? \
2606 rb_gc_impl_pointer_to_heap_p(objspace, (const void *)obj) && \
2607 !rb_gc_impl_garbage_object_p(objspace, obj) : \
2608 true) { \
2609 GC_ASSERT(!rb_gc_impl_during_gc_p(objspace)); \
2610 struct gc_mark_func_data_struct *mark_func_data = vm->gc.mark_func_data; \
2611 vm->gc.mark_func_data = NULL; \
2612 mark_func_data->mark_func((obj), mark_func_data->data); \
2613 vm->gc.mark_func_data = mark_func_data; \
2614 } \
2615 } \
2616} while (0)
2617
2618static inline void
2619gc_mark_internal(VALUE obj)
2620{
2621 RB_GC_MARK_OR_TRAVERSE(rb_gc_impl_mark, obj, obj, false);
2622}
2623
2624void
2625rb_gc_mark_movable(VALUE obj)
2626{
2627 gc_mark_internal(obj);
2628}
2629
2630void
2631rb_gc_mark_and_move(VALUE *ptr)
2632{
2633 RB_GC_MARK_OR_TRAVERSE(rb_gc_impl_mark_and_move, ptr, *ptr, false);
2634}
2635
2636static inline void
2637gc_mark_and_pin_internal(VALUE obj)
2638{
2639 RB_GC_MARK_OR_TRAVERSE(rb_gc_impl_mark_and_pin, obj, obj, false);
2640}
2641
2642void
2643rb_gc_mark(VALUE obj)
2644{
2645 gc_mark_and_pin_internal(obj);
2646}
2647
2648static inline void
2649gc_mark_maybe_internal(VALUE obj)
2650{
2651 RB_GC_MARK_OR_TRAVERSE(rb_gc_impl_mark_maybe, obj, obj, true);
2652}
2653
2654void
2655rb_gc_mark_maybe(VALUE obj)
2656{
2657 gc_mark_maybe_internal(obj);
2658}
2659
2660void
2661rb_gc_mark_weak(VALUE *ptr)
2662{
2663 if (RB_SPECIAL_CONST_P(*ptr)) return;
2664
2665 rb_vm_t *vm = GET_VM();
2666 void *objspace = vm->gc.objspace;
2667 if (LIKELY(vm->gc.mark_func_data == NULL)) {
2668 GC_ASSERT(rb_gc_impl_during_gc_p(objspace));
2669
2670 rb_gc_impl_mark_weak(objspace, ptr);
2671 }
2672 else {
2673 GC_ASSERT(!rb_gc_impl_during_gc_p(objspace));
2674 }
2675}
2676
2677void
2678rb_gc_remove_weak(VALUE parent_obj, VALUE *ptr)
2679{
2680 rb_gc_impl_remove_weak(rb_gc_get_objspace(), parent_obj, ptr);
2681}
2682
2683ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(static void each_location(register const VALUE *x, register long n, void (*cb)(VALUE, void *), void *data));
2684static void
2685each_location(register const VALUE *x, register long n, void (*cb)(VALUE, void *), void *data)
2686{
2687 VALUE v;
2688 while (n--) {
2689 v = *x;
2690 cb(v, data);
2691 x++;
2692 }
2693}
2694
2695static void
2696each_location_ptr(const VALUE *start, const VALUE *end, void (*cb)(VALUE, void *), void *data)
2697{
2698 if (end <= start) return;
2699 each_location(start, end - start, cb, data);
2700}
2701
2702static void
2703gc_mark_maybe_each_location(VALUE obj, void *data)
2704{
2705 gc_mark_maybe_internal(obj);
2706}
2707
2708void
2709rb_gc_mark_locations(const VALUE *start, const VALUE *end)
2710{
2711 each_location_ptr(start, end, gc_mark_maybe_each_location, NULL);
2712}
2713
2714void
2715rb_gc_mark_values(long n, const VALUE *values)
2716{
2717 for (long i = 0; i < n; i++) {
2718 gc_mark_internal(values[i]);
2719 }
2720}
2721
2722void
2723rb_gc_mark_vm_stack_values(long n, const VALUE *values)
2724{
2725 for (long i = 0; i < n; i++) {
2726 gc_mark_and_pin_internal(values[i]);
2727 }
2728}
2729
2730static int
2731mark_key(st_data_t key, st_data_t value, st_data_t data)
2732{
2733 gc_mark_and_pin_internal((VALUE)key);
2734
2735 return ST_CONTINUE;
2736}
2737
2738void
2739rb_mark_set(st_table *tbl)
2740{
2741 if (!tbl) return;
2742
2743 st_foreach(tbl, mark_key, (st_data_t)rb_gc_get_objspace());
2744}
2745
2746static int
2747mark_keyvalue(st_data_t key, st_data_t value, st_data_t data)
2748{
2749 gc_mark_internal((VALUE)key);
2750 gc_mark_internal((VALUE)value);
2751
2752 return ST_CONTINUE;
2753}
2754
2755static int
2756pin_key_pin_value(st_data_t key, st_data_t value, st_data_t data)
2757{
2758 gc_mark_and_pin_internal((VALUE)key);
2759 gc_mark_and_pin_internal((VALUE)value);
2760
2761 return ST_CONTINUE;
2762}
2763
2764static int
2765pin_key_mark_value(st_data_t key, st_data_t value, st_data_t data)
2766{
2767 gc_mark_and_pin_internal((VALUE)key);
2768 gc_mark_internal((VALUE)value);
2769
2770 return ST_CONTINUE;
2771}
2772
2773static void
2774mark_hash(VALUE hash)
2775{
2776 if (rb_hash_compare_by_id_p(hash)) {
2777 rb_hash_stlike_foreach(hash, pin_key_mark_value, 0);
2778 }
2779 else {
2780 rb_hash_stlike_foreach(hash, mark_keyvalue, 0);
2781 }
2782
2783 gc_mark_internal(RHASH(hash)->ifnone);
2784}
2785
2786void
2787rb_mark_hash(st_table *tbl)
2788{
2789 if (!tbl) return;
2790
2791 st_foreach(tbl, pin_key_pin_value, 0);
2792}
2793
2794static enum rb_id_table_iterator_result
2795mark_method_entry_i(VALUE me, void *objspace)
2796{
2797 gc_mark_internal(me);
2798
2799 return ID_TABLE_CONTINUE;
2800}
2801
2802static void
2803mark_m_tbl(void *objspace, struct rb_id_table *tbl)
2804{
2805 if (tbl) {
2806 rb_id_table_foreach_values(tbl, mark_method_entry_i, objspace);
2807 }
2808}
2809
2810static enum rb_id_table_iterator_result
2811mark_const_entry_i(VALUE value, void *objspace)
2812{
2813 const rb_const_entry_t *ce = (const rb_const_entry_t *)value;
2814
2815 if (!rb_gc_checking_shareable()) {
2816 gc_mark_internal(ce->value);
2817 gc_mark_internal(ce->file); // TODO: ce->file should be shareable?
2818 }
2819 return ID_TABLE_CONTINUE;
2820}
2821
2822static void
2823mark_const_tbl(rb_objspace_t *objspace, struct rb_id_table *tbl)
2824{
2825 if (!tbl) return;
2826 rb_id_table_foreach_values(tbl, mark_const_entry_i, objspace);
2827}
2828
2829#if STACK_GROW_DIRECTION < 0
2830#define GET_STACK_BOUNDS(start, end, appendix) ((start) = STACK_END, (end) = STACK_START)
2831#elif STACK_GROW_DIRECTION > 0
2832#define GET_STACK_BOUNDS(start, end, appendix) ((start) = STACK_START, (end) = STACK_END+(appendix))
2833#else
2834#define GET_STACK_BOUNDS(start, end, appendix) \
2835 ((STACK_END < STACK_START) ? \
2836 ((start) = STACK_END, (end) = STACK_START) : ((start) = STACK_START, (end) = STACK_END+(appendix)))
2837#endif
2838
2839static void
2840gc_mark_machine_stack_location_maybe(VALUE obj, void *data)
2841{
2842 gc_mark_maybe_internal(obj);
2843
2844#ifdef RUBY_ASAN_ENABLED
2845 const rb_execution_context_t *ec = (const rb_execution_context_t *)data;
2846 void *fake_frame_start;
2847 void *fake_frame_end;
2848 bool is_fake_frame = asan_get_fake_stack_extents(
2849 ec->machine.asan_fake_stack_handle, obj,
2850 ec->machine.stack_start, ec->machine.stack_end,
2851 &fake_frame_start, &fake_frame_end
2852 );
2853 if (is_fake_frame) {
2854 each_location_ptr(fake_frame_start, fake_frame_end, gc_mark_maybe_each_location, NULL);
2855 }
2856#endif
2857}
2858
2859static bool
2860gc_object_moved_p_internal(void *objspace, VALUE obj)
2861{
2862 if (SPECIAL_CONST_P(obj)) {
2863 return false;
2864 }
2865
2866 return rb_gc_impl_object_moved_p(objspace, obj);
2867}
2868
2869static VALUE
2870gc_location_internal(void *objspace, VALUE value)
2871{
2872 if (SPECIAL_CONST_P(value)) {
2873 return value;
2874 }
2875
2876 GC_ASSERT(rb_gc_impl_pointer_to_heap_p(objspace, (void *)value));
2877
2878 return rb_gc_impl_location(objspace, value);
2879}
2880
2881VALUE
2882rb_gc_location(VALUE value)
2883{
2884 return gc_location_internal(rb_gc_get_objspace(), value);
2885}
2886
2887#if defined(__wasm__)
2888
2889
2890static VALUE *rb_stack_range_tmp[2];
2891
2892static void
2893rb_mark_locations(void *begin, void *end)
2894{
2895 rb_stack_range_tmp[0] = begin;
2896 rb_stack_range_tmp[1] = end;
2897}
2898
2899void
2900rb_gc_save_machine_context(void)
2901{
2902 // no-op
2903}
2904
2905# if defined(__EMSCRIPTEN__)
2906
2907static void
2908mark_current_machine_context(const rb_execution_context_t *ec)
2909{
2910 emscripten_scan_stack(rb_mark_locations);
2911 each_location_ptr(rb_stack_range_tmp[0], rb_stack_range_tmp[1], gc_mark_maybe_each_location, NULL);
2912
2913 emscripten_scan_registers(rb_mark_locations);
2914 each_location_ptr(rb_stack_range_tmp[0], rb_stack_range_tmp[1], gc_mark_maybe_each_location, NULL);
2915}
2916# else // use Asyncify version
2917
2918static void
2919mark_current_machine_context(rb_execution_context_t *ec)
2920{
2921 VALUE *stack_start, *stack_end;
2922 SET_STACK_END;
2923 GET_STACK_BOUNDS(stack_start, stack_end, 1);
2924 each_location_ptr(stack_start, stack_end, gc_mark_maybe_each_location, NULL);
2925
2926 rb_wasm_scan_locals(rb_mark_locations);
2927 each_location_ptr(rb_stack_range_tmp[0], rb_stack_range_tmp[1], gc_mark_maybe_each_location, NULL);
2928}
2929
2930# endif
2931
2932#else // !defined(__wasm__)
2933
2934void
2935rb_gc_save_machine_context(void)
2936{
2937 rb_thread_t *thread = GET_THREAD();
2938
2939 RB_VM_SAVE_MACHINE_CONTEXT(thread);
2940}
2941
2942
2943static void
2944mark_current_machine_context(const rb_execution_context_t *ec)
2945{
2946 rb_gc_mark_machine_context(ec);
2947}
2948#endif
2949
2950void
2951rb_gc_mark_machine_context(const rb_execution_context_t *ec)
2952{
2953 VALUE *stack_start, *stack_end;
2954
2955 GET_STACK_BOUNDS(stack_start, stack_end, 0);
2956 RUBY_DEBUG_LOG("ec->th:%u stack_start:%p stack_end:%p", rb_ec_thread_ptr(ec)->serial, stack_start, stack_end);
2957
2958 void *data =
2959#ifdef RUBY_ASAN_ENABLED
2960 /* gc_mark_machine_stack_location_maybe() uses data as const */
2961 (rb_execution_context_t *)ec;
2962#else
2963 NULL;
2964#endif
2965
2966 each_location_ptr(stack_start, stack_end, gc_mark_machine_stack_location_maybe, data);
2967 int num_regs = sizeof(ec->machine.regs)/(sizeof(VALUE));
2968 each_location((VALUE*)&ec->machine.regs, num_regs, gc_mark_machine_stack_location_maybe, data);
2969}
2970
2971static int
2972rb_mark_tbl_i(st_data_t key, st_data_t value, st_data_t data)
2973{
2974 gc_mark_and_pin_internal((VALUE)value);
2975
2976 return ST_CONTINUE;
2977}
2978
2979void
2980rb_mark_tbl(st_table *tbl)
2981{
2982 if (!tbl || tbl->num_entries == 0) return;
2983
2984 st_foreach(tbl, rb_mark_tbl_i, 0);
2985}
2986
2987static void
2988gc_mark_tbl_no_pin(st_table *tbl)
2989{
2990 if (!tbl || tbl->num_entries == 0) return;
2991
2992 st_foreach(tbl, gc_mark_tbl_no_pin_i, 0);
2993}
2994
2995void
2996rb_mark_tbl_no_pin(st_table *tbl)
2997{
2998 gc_mark_tbl_no_pin(tbl);
2999}
3000
3001static bool
3002gc_declarative_marking_p(const rb_data_type_t *type)
3003{
3004 return (type->flags & RUBY_TYPED_DECL_MARKING) != 0;
3005}
3006
3007void
3008rb_gc_mark_roots(void *objspace, const char **categoryp)
3009{
3010 rb_execution_context_t *ec = GET_EC();
3011 rb_vm_t *vm = rb_ec_vm_ptr(ec);
3012
3013#define MARK_CHECKPOINT(category) do { \
3014 if (categoryp) *categoryp = category; \
3015} while (0)
3016
3017 MARK_CHECKPOINT("vm");
3018 rb_vm_mark(vm);
3019
3020 MARK_CHECKPOINT("end_proc");
3021 rb_mark_end_proc();
3022
3023 MARK_CHECKPOINT("global_tbl");
3024 rb_gc_mark_global_tbl();
3025
3026#if USE_YJIT
3027 void rb_yjit_root_mark(void); // in Rust
3028
3029 if (rb_yjit_enabled_p) {
3030 MARK_CHECKPOINT("YJIT");
3031 rb_yjit_root_mark();
3032 }
3033#endif
3034
3035#if USE_ZJIT
3036 void rb_zjit_root_mark(void);
3037 if (rb_zjit_enabled_p) {
3038 MARK_CHECKPOINT("ZJIT");
3039 rb_zjit_root_mark();
3040 }
3041#endif
3042
3043 MARK_CHECKPOINT("machine_context");
3044 mark_current_machine_context(ec);
3045
3046 MARK_CHECKPOINT("global_symbols");
3047 rb_sym_global_symbols_mark_and_move();
3048
3049 MARK_CHECKPOINT("finish");
3050
3051#undef MARK_CHECKPOINT
3052}
3053
3055 rb_objspace_t *objspace;
3056 VALUE obj;
3057};
3058
3059static void
3060gc_mark_classext_module(rb_classext_t *ext, bool prime, VALUE box_value, void *arg)
3061{
3063 rb_objspace_t *objspace = foreach_arg->objspace;
3064
3065 if (RCLASSEXT_SUPER(ext)) {
3066 gc_mark_internal(RCLASSEXT_SUPER(ext));
3067 }
3068 mark_m_tbl(objspace, RCLASSEXT_M_TBL(ext));
3069
3070 if (!rb_gc_checking_shareable()) {
3071 // unshareable
3072 gc_mark_internal(RCLASSEXT_FIELDS_OBJ(ext));
3073 gc_mark_internal(RCLASSEXT_CVC_TBL(ext));
3074 }
3075
3076 if (!RCLASSEXT_SHARED_CONST_TBL(ext) && RCLASSEXT_CONST_TBL(ext)) {
3077 mark_const_tbl(objspace, RCLASSEXT_CONST_TBL(ext));
3078 }
3079 mark_m_tbl(objspace, RCLASSEXT_CALLABLE_M_TBL(ext));
3080 gc_mark_internal(RCLASSEXT_CC_TBL(ext));
3081 gc_mark_internal(RCLASSEXT_CLASSPATH(ext));
3082}
3083
3084static void
3085gc_mark_classext_iclass(rb_classext_t *ext, bool prime, VALUE box_value, void *arg)
3086{
3088 rb_objspace_t *objspace = foreach_arg->objspace;
3089
3090 if (RCLASSEXT_SUPER(ext)) {
3091 gc_mark_internal(RCLASSEXT_SUPER(ext));
3092 }
3093 if (RCLASSEXT_ICLASS_IS_ORIGIN(ext) && !RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext)) {
3094 mark_m_tbl(objspace, RCLASSEXT_M_TBL(ext));
3095 }
3096 if (RCLASSEXT_INCLUDER(ext)) {
3097 gc_mark_internal(RCLASSEXT_INCLUDER(ext));
3098 }
3099 mark_m_tbl(objspace, RCLASSEXT_CALLABLE_M_TBL(ext));
3100 gc_mark_internal(RCLASSEXT_CC_TBL(ext));
3101}
3102
3103#define TYPED_DATA_REFS_OFFSET_LIST(d) (size_t *)(uintptr_t)RTYPEDDATA_TYPE(d)->function.dmark
3104
3105void
3106rb_gc_mark_children(void *objspace, VALUE obj)
3107{
3108 struct gc_mark_classext_foreach_arg foreach_args;
3109
3110 if (rb_obj_gen_fields_p(obj)) {
3111 rb_mark_generic_ivar(obj);
3112 }
3113
3114 switch (BUILTIN_TYPE(obj)) {
3115 case T_FLOAT:
3116 case T_BIGNUM:
3117 return;
3118
3119 case T_NIL:
3120 case T_FIXNUM:
3121 rb_bug("rb_gc_mark() called for broken object");
3122 break;
3123
3124 case T_NODE:
3125 UNEXPECTED_NODE(rb_gc_mark);
3126 break;
3127
3128 case T_IMEMO:
3129 rb_imemo_mark_and_move(obj, false);
3130 return;
3131
3132 default:
3133 break;
3134 }
3135
3136 gc_mark_internal(RBASIC(obj)->klass);
3137
3138 switch (BUILTIN_TYPE(obj)) {
3139 case T_CLASS:
3140 if (FL_TEST_RAW(obj, FL_SINGLETON) &&
3141 !rb_gc_checking_shareable()) {
3142 gc_mark_internal(RCLASS_ATTACHED_OBJECT(obj));
3143 }
3144 // Continue to the shared T_CLASS/T_MODULE
3145 case T_MODULE:
3146 foreach_args.objspace = objspace;
3147 foreach_args.obj = obj;
3148 rb_class_classext_foreach(obj, gc_mark_classext_module, (void *)&foreach_args);
3149 if (BOX_USER_P(RCLASS_PRIME_BOX(obj))) {
3150 gc_mark_internal(RCLASS_PRIME_BOX(obj)->box_object);
3151 }
3152 break;
3153
3154 case T_ICLASS:
3155 foreach_args.objspace = objspace;
3156 foreach_args.obj = obj;
3157 rb_class_classext_foreach(obj, gc_mark_classext_iclass, (void *)&foreach_args);
3158 if (BOX_USER_P(RCLASS_PRIME_BOX(obj))) {
3159 gc_mark_internal(RCLASS_PRIME_BOX(obj)->box_object);
3160 }
3161 break;
3162
3163 case T_ARRAY:
3164 if (ARY_SHARED_P(obj)) {
3165 VALUE root = ARY_SHARED_ROOT(obj);
3166 gc_mark_internal(root);
3167 }
3168 else {
3169 long len = RARRAY_LEN(obj);
3170 const VALUE *ptr = RARRAY_CONST_PTR(obj);
3171 for (long i = 0; i < len; i++) {
3172 gc_mark_internal(ptr[i]);
3173 }
3174 }
3175 break;
3176
3177 case T_HASH:
3178 mark_hash(obj);
3179 break;
3180
3181 case T_SYMBOL:
3182 gc_mark_internal(RSYMBOL(obj)->fstr);
3183 break;
3184
3185 case T_STRING:
3186 if (STR_SHARED_P(obj)) {
3187 if (STR_EMBED_P(RSTRING(obj)->as.heap.aux.shared)) {
3188 /* Embedded shared strings cannot be moved because this string
3189 * points into the slot of the shared string. There may be code
3190 * using the RSTRING_PTR on the stack, which would pin this
3191 * string but not pin the shared string, causing it to move. */
3192 gc_mark_and_pin_internal(RSTRING(obj)->as.heap.aux.shared);
3193 }
3194 else {
3195 gc_mark_internal(RSTRING(obj)->as.heap.aux.shared);
3196 }
3197 }
3198 break;
3199
3200 case T_DATA: {
3201 bool typed_data = RTYPEDDATA_P(obj);
3202 void *const ptr = typed_data ? RTYPEDDATA_GET_DATA(obj) : DATA_PTR(obj);
3203
3204 if (typed_data) {
3205 gc_mark_internal(RTYPEDDATA(obj)->fields_obj);
3206 }
3207
3208 if (ptr) {
3209 if (typed_data && gc_declarative_marking_p(RTYPEDDATA_TYPE(obj))) {
3210 size_t *offset_list = TYPED_DATA_REFS_OFFSET_LIST(obj);
3211
3212 for (size_t offset = *offset_list; offset != RUBY_REF_END; offset = *offset_list++) {
3213 gc_mark_internal(*(VALUE *)((char *)ptr + offset));
3214 }
3215 }
3216 else {
3217 RUBY_DATA_FUNC mark_func = typed_data ?
3218 RTYPEDDATA_TYPE(obj)->function.dmark :
3219 RDATA(obj)->dmark;
3220 if (mark_func) (*mark_func)(ptr);
3221 }
3222 }
3223
3224 break;
3225 }
3226
3227 case T_OBJECT: {
3228 uint32_t len;
3229 if (rb_shape_obj_too_complex_p(obj)) {
3230 gc_mark_tbl_no_pin(ROBJECT_FIELDS_HASH(obj));
3231 len = ROBJECT_FIELDS_COUNT_COMPLEX(obj);
3232 }
3233 else {
3234 const VALUE * const ptr = ROBJECT_FIELDS(obj);
3235
3236 len = ROBJECT_FIELDS_COUNT_NOT_COMPLEX(obj);
3237 for (uint32_t i = 0; i < len; i++) {
3238 gc_mark_internal(ptr[i]);
3239 }
3240 }
3241
3242 attr_index_t fields_count = (attr_index_t)len;
3243 if (fields_count) {
3244 VALUE klass = RBASIC_CLASS(obj);
3245
3246 // Increment max_iv_count if applicable, used to determine size pool allocation
3247 if (RCLASS_MAX_IV_COUNT(klass) < fields_count) {
3248 RCLASS_SET_MAX_IV_COUNT(klass, fields_count);
3249 }
3250 }
3251
3252 break;
3253 }
3254
3255 case T_FILE:
3256 if (RFILE(obj)->fptr) {
3257 gc_mark_internal(RFILE(obj)->fptr->self);
3258 gc_mark_internal(RFILE(obj)->fptr->pathv);
3259 gc_mark_internal(RFILE(obj)->fptr->tied_io_for_writing);
3260 gc_mark_internal(RFILE(obj)->fptr->writeconv_asciicompat);
3261 gc_mark_internal(RFILE(obj)->fptr->writeconv_pre_ecopts);
3262 gc_mark_internal(RFILE(obj)->fptr->encs.ecopts);
3263 gc_mark_internal(RFILE(obj)->fptr->write_lock);
3264 gc_mark_internal(RFILE(obj)->fptr->timeout);
3265 gc_mark_internal(RFILE(obj)->fptr->wakeup_mutex);
3266 }
3267 break;
3268
3269 case T_REGEXP:
3270 gc_mark_internal(RREGEXP(obj)->src);
3271 break;
3272
3273 case T_MATCH:
3274 gc_mark_internal(RMATCH(obj)->regexp);
3275 if (RMATCH(obj)->str) {
3276 gc_mark_internal(RMATCH(obj)->str);
3277 }
3278 break;
3279
3280 case T_RATIONAL:
3281 gc_mark_internal(RRATIONAL(obj)->num);
3282 gc_mark_internal(RRATIONAL(obj)->den);
3283 break;
3284
3285 case T_COMPLEX:
3286 gc_mark_internal(RCOMPLEX(obj)->real);
3287 gc_mark_internal(RCOMPLEX(obj)->imag);
3288 break;
3289
3290 case T_STRUCT: {
3291 const long len = RSTRUCT_LEN(obj);
3292 const VALUE * const ptr = RSTRUCT_CONST_PTR(obj);
3293
3294 for (long i = 0; i < len; i++) {
3295 gc_mark_internal(ptr[i]);
3296 }
3297
3298 if (rb_shape_obj_has_fields(obj) && !FL_TEST_RAW(obj, RSTRUCT_GEN_FIELDS)) {
3299 gc_mark_internal(RSTRUCT_FIELDS_OBJ(obj));
3300 }
3301
3302 break;
3303 }
3304
3305 default:
3306 if (BUILTIN_TYPE(obj) == T_MOVED) rb_bug("rb_gc_mark(): %p is T_MOVED", (void *)obj);
3307 if (BUILTIN_TYPE(obj) == T_NONE) rb_bug("rb_gc_mark(): %p is T_NONE", (void *)obj);
3308 if (BUILTIN_TYPE(obj) == T_ZOMBIE) rb_bug("rb_gc_mark(): %p is T_ZOMBIE", (void *)obj);
3309 rb_bug("rb_gc_mark(): unknown data type 0x%x(%p) %s",
3310 BUILTIN_TYPE(obj), (void *)obj,
3311 rb_gc_impl_pointer_to_heap_p(objspace, (void *)obj) ? "corrupted object" : "non object");
3312 }
3313}
3314
3315size_t
3316rb_gc_obj_optimal_size(VALUE obj)
3317{
3318 switch (BUILTIN_TYPE(obj)) {
3319 case T_ARRAY:
3320 {
3321 size_t size = rb_ary_size_as_embedded(obj);
3322 if (rb_gc_size_allocatable_p(size)) {
3323 return size;
3324 }
3325 else {
3326 return sizeof(struct RArray);
3327 }
3328 }
3329
3330 case T_OBJECT:
3331 if (rb_shape_obj_too_complex_p(obj)) {
3332 return sizeof(struct RObject);
3333 }
3334 else {
3335 size_t size = rb_obj_embedded_size(ROBJECT_FIELDS_CAPACITY(obj));
3336 if (rb_gc_size_allocatable_p(size)) {
3337 return size;
3338 }
3339 else {
3340 return sizeof(struct RObject);
3341 }
3342 }
3343
3344 case T_STRING:
3345 {
3346 size_t size = rb_str_size_as_embedded(obj);
3347 if (rb_gc_size_allocatable_p(size)) {
3348 return size;
3349 }
3350 else {
3351 return sizeof(struct RString);
3352 }
3353 }
3354
3355 case T_HASH:
3356 return sizeof(struct RHash) + (RHASH_ST_TABLE_P(obj) ? sizeof(st_table) : sizeof(ar_table));
3357
3358 default:
3359 return 0;
3360 }
3361}
3362
3363void
3364rb_gc_writebarrier(VALUE a, VALUE b)
3365{
3366 rb_gc_impl_writebarrier(rb_gc_get_objspace(), a, b);
3367}
3368
3369void
3370rb_gc_writebarrier_unprotect(VALUE obj)
3371{
3372 rb_gc_impl_writebarrier_unprotect(rb_gc_get_objspace(), obj);
3373}
3374
3375/*
3376 * remember `obj' if needed.
3377 */
3378void
3379rb_gc_writebarrier_remember(VALUE obj)
3380{
3381 rb_gc_impl_writebarrier_remember(rb_gc_get_objspace(), obj);
3382}
3383
3384void
3385rb_gc_copy_attributes(VALUE dest, VALUE obj)
3386{
3387 rb_gc_impl_copy_attributes(rb_gc_get_objspace(), dest, obj);
3388}
3389
3390int
3391rb_gc_modular_gc_loaded_p(void)
3392{
3393#if USE_MODULAR_GC
3394 return rb_gc_functions.modular_gc_loaded_p;
3395#else
3396 return false;
3397#endif
3398}
3399
3400const char *
3401rb_gc_active_gc_name(void)
3402{
3403 const char *gc_name = rb_gc_impl_active_gc_name();
3404
3405 const size_t len = strlen(gc_name);
3406 if (len > RB_GC_MAX_NAME_LEN) {
3407 rb_bug("GC should have a name no more than %d chars long. Currently: %zu (%s)",
3408 RB_GC_MAX_NAME_LEN, len, gc_name);
3409 }
3410
3411 return gc_name;
3412}
3413
3415rb_gc_object_metadata(VALUE obj)
3416{
3417 return rb_gc_impl_object_metadata(rb_gc_get_objspace(), obj);
3418}
3419
3420/* GC */
3421
3422void *
3423rb_gc_ractor_cache_alloc(rb_ractor_t *ractor)
3424{
3425 return rb_gc_impl_ractor_cache_alloc(rb_gc_get_objspace(), ractor);
3426}
3427
3428void
3429rb_gc_ractor_cache_free(void *cache)
3430{
3431 rb_gc_impl_ractor_cache_free(rb_gc_get_objspace(), cache);
3432}
3433
3434void
3435rb_gc_register_mark_object(VALUE obj)
3436{
3437 /* rb_gc_impl_pointer_to_heap_p() walks objspace->heap_pages.sorted, which
3438 * another ractor may mutate while allocating heap pages under the VM lock,
3439 * so the lookup must be done under the VM lock as well. */
3440 RB_VM_LOCKING() {
3441 if (rb_gc_impl_pointer_to_heap_p(rb_gc_get_objspace(), (void *)obj)) {
3442 rb_vm_register_global_object(obj);
3443 }
3444 }
3445}
3446
3447void
3448rb_gc_register_address(VALUE *addr)
3449{
3450 rb_vm_t *vm = GET_VM();
3451
3452 VALUE obj = *addr;
3453
3454 struct global_object_list *tmp = ALLOC(struct global_object_list);
3455 tmp->next = vm->global_object_list;
3456 tmp->varptr = addr;
3457 vm->global_object_list = tmp;
3458
3459 /*
3460 * Because some C extensions have assignment-then-register bugs,
3461 * we guard `obj` here so that it would not get swept defensively.
3462 */
3463 RB_GC_GUARD(obj);
3464 if (0 && !SPECIAL_CONST_P(obj)) {
3465 rb_warn("Object is assigned to registering address already: %"PRIsVALUE,
3466 rb_obj_class(obj));
3467 rb_print_backtrace(stderr);
3468 }
3469}
3470
3471void
3472rb_gc_unregister_address(VALUE *addr)
3473{
3474 rb_vm_t *vm = GET_VM();
3475 struct global_object_list *tmp = vm->global_object_list;
3476
3477 if (tmp->varptr == addr) {
3478 vm->global_object_list = tmp->next;
3479 xfree(tmp);
3480 return;
3481 }
3482 while (tmp->next) {
3483 if (tmp->next->varptr == addr) {
3484 struct global_object_list *t = tmp->next;
3485
3486 tmp->next = tmp->next->next;
3487 xfree(t);
3488 break;
3489 }
3490 tmp = tmp->next;
3491 }
3492}
3493
3494void
3496{
3497 rb_gc_register_address(var);
3498}
3499
3500static VALUE
3501gc_start_internal(rb_execution_context_t *ec, VALUE self, VALUE full_mark, VALUE immediate_mark, VALUE immediate_sweep, VALUE compact)
3502{
3503 rb_gc_impl_start(rb_gc_get_objspace(), RTEST(full_mark), RTEST(immediate_mark), RTEST(immediate_sweep), RTEST(compact));
3504
3505 return Qnil;
3506}
3507
3508/*
3509 * rb_objspace_each_objects() is special C API to walk through
3510 * Ruby object space. This C API is too difficult to use it.
3511 * To be frank, you should not use it. Or you need to read the
3512 * source code of this function and understand what this function does.
3513 *
3514 * 'callback' will be called several times (the number of heap page,
3515 * at current implementation) with:
3516 * vstart: a pointer to the first living object of the heap_page.
3517 * vend: a pointer to next to the valid heap_page area.
3518 * stride: a distance to next VALUE.
3519 *
3520 * If callback() returns non-zero, the iteration will be stopped.
3521 *
3522 * This is a sample callback code to iterate liveness objects:
3523 *
3524 * static int
3525 * sample_callback(void *vstart, void *vend, int stride, void *data)
3526 * {
3527 * VALUE v = (VALUE)vstart;
3528 * for (; v != (VALUE)vend; v += stride) {
3529 * if (!rb_objspace_internal_object_p(v)) { // liveness check
3530 * // do something with live object 'v'
3531 * }
3532 * }
3533 * return 0; // continue to iteration
3534 * }
3535 *
3536 * Note: 'vstart' is not a top of heap_page. This point the first
3537 * living object to grasp at least one object to avoid GC issue.
3538 * This means that you can not walk through all Ruby object page
3539 * including freed object page.
3540 *
3541 * Note: On this implementation, 'stride' is the same as sizeof(RVALUE).
3542 * However, there are possibilities to pass variable values with
3543 * 'stride' with some reasons. You must use stride instead of
3544 * use some constant value in the iteration.
3545 */
3546void
3547rb_objspace_each_objects(int (*callback)(void *, void *, size_t, void *), void *data)
3548{
3549 rb_gc_impl_each_objects(rb_gc_get_objspace(), callback, data);
3550}
3551
3552static void
3553gc_ref_update_array(void *objspace, VALUE v)
3554{
3555 if (ARY_SHARED_P(v)) {
3556 VALUE old_root = RARRAY(v)->as.heap.aux.shared_root;
3557
3558 UPDATE_IF_MOVED(objspace, RARRAY(v)->as.heap.aux.shared_root);
3559
3560 VALUE new_root = RARRAY(v)->as.heap.aux.shared_root;
3561 // If the root is embedded and its location has changed
3562 if (ARY_EMBED_P(new_root) && new_root != old_root) {
3563 size_t offset = (size_t)(RARRAY(v)->as.heap.ptr - RARRAY(old_root)->as.ary);
3564 GC_ASSERT(RARRAY(v)->as.heap.ptr >= RARRAY(old_root)->as.ary);
3565 RARRAY(v)->as.heap.ptr = RARRAY(new_root)->as.ary + offset;
3566 }
3567 }
3568 else {
3569 long len = RARRAY_LEN(v);
3570
3571 if (len > 0) {
3573 for (long i = 0; i < len; i++) {
3574 UPDATE_IF_MOVED(objspace, ptr[i]);
3575 }
3576 }
3577
3578 if (!ARY_EMBED_P(v) && rb_gc_obj_slot_size(v) >= rb_ary_size_as_embedded(v)) {
3579 /* Skip pinned arrays: a pinned array may be referenced from a
3580 * conservative root holding RARRAY_PTR across this compaction, so
3581 * freeing its heap buffer here would dangle that pointer. */
3582 if (rb_ary_embeddable_p(v) && !rb_gc_impl_pinned_p(objspace, v)) {
3583 rb_ary_make_embedded(v);
3584 }
3585 }
3586 }
3587}
3588
3589static void
3590gc_ref_update_object(void *objspace, VALUE v)
3591{
3592 VALUE *ptr = ROBJECT_FIELDS(v);
3593
3594 if (FL_TEST_RAW(v, ROBJECT_HEAP)) {
3595 if (rb_shape_obj_too_complex_p(v)) {
3596 gc_ref_update_table_values_only(ROBJECT_FIELDS_HASH(v));
3597 return;
3598 }
3599
3600 size_t slot_size = rb_gc_obj_slot_size(v);
3601 size_t embed_size = rb_obj_embedded_size(ROBJECT_FIELDS_CAPACITY(v));
3602 if (slot_size >= embed_size) {
3603 // Object can be re-embedded
3604 memcpy(ROBJECT(v)->as.ary, ptr, sizeof(VALUE) * ROBJECT_FIELDS_COUNT(v));
3605 FL_UNSET_RAW(v, ROBJECT_HEAP);
3606 xfree(ptr);
3607 ptr = ROBJECT(v)->as.ary;
3608 }
3609 }
3610
3611 for (uint32_t i = 0; i < ROBJECT_FIELDS_COUNT(v); i++) {
3612 UPDATE_IF_MOVED(objspace, ptr[i]);
3613 }
3614}
3615
3616void
3617rb_gc_ref_update_table_values_only(st_table *tbl)
3618{
3619 gc_ref_update_table_values_only(tbl);
3620}
3621
3622/* Update MOVED references in a VALUE=>VALUE st_table */
3623void
3624rb_gc_update_tbl_refs(st_table *ptr)
3625{
3626 gc_update_table_refs(ptr);
3627}
3628
3629static void
3630gc_ref_update_hash(void *objspace, VALUE v)
3631{
3632 rb_hash_stlike_foreach_with_replace(v, hash_foreach_replace, hash_replace_ref, (st_data_t)objspace);
3633}
3634
3635static void
3636gc_update_values(void *objspace, long n, VALUE *values)
3637{
3638 for (long i = 0; i < n; i++) {
3639 UPDATE_IF_MOVED(objspace, values[i]);
3640 }
3641}
3642
3643void
3644rb_gc_update_values(long n, VALUE *values)
3645{
3646 gc_update_values(rb_gc_get_objspace(), n, values);
3647}
3648
3649static enum rb_id_table_iterator_result
3650check_id_table_move(VALUE value, void *data)
3651{
3652 void *objspace = (void *)data;
3653
3654 if (gc_object_moved_p_internal(objspace, (VALUE)value)) {
3655 return ID_TABLE_REPLACE;
3656 }
3657
3658 return ID_TABLE_CONTINUE;
3659}
3660
3661void
3662rb_gc_prepare_heap_process_object(VALUE obj)
3663{
3664 switch (BUILTIN_TYPE(obj)) {
3665 case T_STRING:
3666 // Precompute the string coderange. This both save time for when it will be
3667 // eventually needed, and avoid mutating heap pages after a potential fork.
3669 break;
3670 default:
3671 break;
3672 }
3673}
3674
3675void
3676rb_gc_prepare_heap(void)
3677{
3678 rb_gc_impl_prepare_heap(rb_gc_get_objspace());
3679}
3680
3681size_t
3682rb_gc_heap_id_for_size(size_t size)
3683{
3684 return rb_gc_impl_heap_id_for_size(rb_gc_get_objspace(), size);
3685}
3686
3687bool
3688rb_gc_size_allocatable_p(size_t size)
3689{
3690 return rb_gc_impl_size_allocatable_p(size);
3691}
3692
3693static enum rb_id_table_iterator_result
3694update_id_table(VALUE *value, void *data, int existing)
3695{
3696 void *objspace = (void *)data;
3697
3698 if (gc_object_moved_p_internal(objspace, (VALUE)*value)) {
3699 *value = gc_location_internal(objspace, (VALUE)*value);
3700 }
3701
3702 return ID_TABLE_CONTINUE;
3703}
3704
3705static void
3706update_m_tbl(void *objspace, struct rb_id_table *tbl)
3707{
3708 if (tbl) {
3709 rb_id_table_foreach_values_with_replace(tbl, check_id_table_move, update_id_table, objspace);
3710 }
3711}
3712
3713static enum rb_id_table_iterator_result
3714update_const_tbl_i(VALUE value, void *objspace)
3715{
3716 rb_const_entry_t *ce = (rb_const_entry_t *)value;
3717
3718 if (gc_object_moved_p_internal(objspace, ce->value)) {
3719 ce->value = gc_location_internal(objspace, ce->value);
3720 }
3721
3722 if (gc_object_moved_p_internal(objspace, ce->file)) {
3723 ce->file = gc_location_internal(objspace, ce->file);
3724 }
3725
3726 return ID_TABLE_CONTINUE;
3727}
3728
3729static void
3730update_const_tbl(void *objspace, struct rb_id_table *tbl)
3731{
3732 if (!tbl) return;
3733 rb_id_table_foreach_values(tbl, update_const_tbl_i, objspace);
3734}
3735
3736static void
3737update_subclasses(void *objspace, rb_classext_t *ext)
3738{
3739 rb_subclass_entry_t *entry = RCLASSEXT_SUBCLASSES(ext);
3740 if (!entry) return;
3741 while (entry) {
3742 if (entry->klass)
3743 UPDATE_IF_MOVED(objspace, entry->klass);
3744 entry = entry->next;
3745 }
3746}
3747
3748static void
3749update_superclasses(rb_objspace_t *objspace, rb_classext_t *ext)
3750{
3751 if (RCLASSEXT_SUPERCLASSES_WITH_SELF(ext)) {
3752 size_t array_size = RCLASSEXT_SUPERCLASS_DEPTH(ext) + 1;
3753 for (size_t i = 0; i < array_size; i++) {
3754 UPDATE_IF_MOVED(objspace, RCLASSEXT_SUPERCLASSES(ext)[i]);
3755 }
3756 }
3757}
3758
3759static void
3760update_classext_values(rb_objspace_t *objspace, rb_classext_t *ext, bool is_iclass)
3761{
3762 UPDATE_IF_MOVED(objspace, RCLASSEXT_ORIGIN(ext));
3763 UPDATE_IF_MOVED(objspace, RCLASSEXT_REFINED_CLASS(ext));
3764 UPDATE_IF_MOVED(objspace, RCLASSEXT_CLASSPATH(ext));
3765 if (is_iclass) {
3766 UPDATE_IF_MOVED(objspace, RCLASSEXT_INCLUDER(ext));
3767 }
3768}
3769
3770static void
3771update_classext(rb_classext_t *ext, bool is_prime, VALUE box_value, void *arg)
3772{
3773 struct classext_foreach_args *args = (struct classext_foreach_args *)arg;
3774 rb_objspace_t *objspace = args->objspace;
3775
3776 if (RCLASSEXT_SUPER(ext)) {
3777 UPDATE_IF_MOVED(objspace, RCLASSEXT_SUPER(ext));
3778 }
3779
3780 update_m_tbl(objspace, RCLASSEXT_M_TBL(ext));
3781
3782 UPDATE_IF_MOVED(objspace, ext->fields_obj);
3783 if (!RCLASSEXT_SHARED_CONST_TBL(ext)) {
3784 update_const_tbl(objspace, RCLASSEXT_CONST_TBL(ext));
3785 }
3786 UPDATE_IF_MOVED(objspace, RCLASSEXT_CC_TBL(ext));
3787 UPDATE_IF_MOVED(objspace, RCLASSEXT_CVC_TBL(ext));
3788 update_superclasses(objspace, ext);
3789 update_subclasses(objspace, ext);
3790
3791 update_classext_values(objspace, ext, false);
3792}
3793
3794static void
3795update_iclass_classext(rb_classext_t *ext, bool is_prime, VALUE box_value, void *arg)
3796{
3797 struct classext_foreach_args *args = (struct classext_foreach_args *)arg;
3798 rb_objspace_t *objspace = args->objspace;
3799
3800 if (RCLASSEXT_SUPER(ext)) {
3801 UPDATE_IF_MOVED(objspace, RCLASSEXT_SUPER(ext));
3802 }
3803 update_m_tbl(objspace, RCLASSEXT_M_TBL(ext));
3804 update_m_tbl(objspace, RCLASSEXT_CALLABLE_M_TBL(ext));
3805 UPDATE_IF_MOVED(objspace, RCLASSEXT_CC_TBL(ext));
3806 UPDATE_IF_MOVED(objspace, RCLASSEXT_CVC_TBL(ext));
3807 update_subclasses(objspace, ext);
3808
3809 update_classext_values(objspace, ext, true);
3810}
3811
3813 vm_table_foreach_callback_func callback;
3814 vm_table_update_callback_func update_callback;
3815 void *data;
3816 bool weak_only;
3817};
3818
3819static int
3820vm_weak_table_foreach_weak_key(st_data_t key, st_data_t value, st_data_t data, int error)
3821{
3822 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3823
3824 int ret = iter_data->callback((VALUE)key, iter_data->data);
3825
3826 if (!iter_data->weak_only) {
3827 if (ret != ST_CONTINUE) return ret;
3828
3829 ret = iter_data->callback((VALUE)value, iter_data->data);
3830 }
3831
3832 return ret;
3833}
3834
3835static int
3836vm_weak_table_foreach_update_weak_key(st_data_t *key, st_data_t *value, st_data_t data, int existing)
3837{
3838 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3839
3840 int ret = iter_data->update_callback((VALUE *)key, iter_data->data);
3841
3842 if (!iter_data->weak_only) {
3843 if (ret != ST_CONTINUE) return ret;
3844
3845 ret = iter_data->update_callback((VALUE *)value, iter_data->data);
3846 }
3847
3848 return ret;
3849}
3850
3851static int
3852vm_weak_table_cc_refinement_foreach(st_data_t key, st_data_t data, int error)
3853{
3854 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3855
3856 return iter_data->callback((VALUE)key, iter_data->data);
3857}
3858
3859static int
3860vm_weak_table_cc_refinement_foreach_update_update(st_data_t *key, st_data_t data, int existing)
3861{
3862 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3863
3864 return iter_data->update_callback((VALUE *)key, iter_data->data);
3865}
3866
3867
3868static int
3869vm_weak_table_sym_set_foreach(VALUE *sym_ptr, void *data)
3870{
3871 VALUE sym = *sym_ptr;
3872 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3873
3874 if (RB_SPECIAL_CONST_P(sym)) return ST_CONTINUE;
3875
3876 int ret = iter_data->callback(sym, iter_data->data);
3877
3878 if (ret == ST_REPLACE) {
3879 ret = iter_data->update_callback(sym_ptr, iter_data->data);
3880 }
3881
3882 return ret;
3883}
3884
3885struct st_table *rb_generic_fields_tbl_get(void);
3886
3887static int
3888vm_weak_table_id2ref_foreach(st_data_t key, st_data_t value, st_data_t data, int error)
3889{
3890 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3891
3892 if (!iter_data->weak_only && !FIXNUM_P((VALUE)key)) {
3893 int ret = iter_data->callback((VALUE)key, iter_data->data);
3894 if (ret != ST_CONTINUE) return ret;
3895 }
3896
3897 return iter_data->callback((VALUE)value, iter_data->data);
3898}
3899
3900static int
3901vm_weak_table_id2ref_foreach_update(st_data_t *key, st_data_t *value, st_data_t data, int existing)
3902{
3903 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3904
3905 iter_data->update_callback((VALUE *)value, iter_data->data);
3906
3907 if (!iter_data->weak_only && !FIXNUM_P((VALUE)*key)) {
3908 iter_data->update_callback((VALUE *)key, iter_data->data);
3909 }
3910
3911 return ST_CONTINUE;
3912}
3913
3914static int
3915vm_weak_table_gen_fields_foreach(st_data_t key, st_data_t value, st_data_t data)
3916{
3917 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3918
3919 int ret = iter_data->callback((VALUE)key, iter_data->data);
3920
3921 VALUE new_value = (VALUE)value;
3922 VALUE new_key = (VALUE)key;
3923
3924 switch (ret) {
3925 case ST_CONTINUE:
3926 break;
3927
3928 case ST_DELETE:
3929 RBASIC_SET_SHAPE_ID((VALUE)key, ROOT_SHAPE_ID);
3930 return ST_DELETE;
3931
3932 case ST_REPLACE: {
3933 ret = iter_data->update_callback(&new_key, iter_data->data);
3934 if (key != new_key) {
3935 ret = ST_DELETE;
3936 }
3937 break;
3938 }
3939
3940 default:
3941 rb_bug("vm_weak_table_gen_fields_foreach: return value %d not supported", ret);
3942 }
3943
3944 if (!iter_data->weak_only) {
3945 int ivar_ret = iter_data->callback(new_value, iter_data->data);
3946 switch (ivar_ret) {
3947 case ST_CONTINUE:
3948 break;
3949
3950 case ST_REPLACE:
3951 iter_data->update_callback(&new_value, iter_data->data);
3952 break;
3953
3954 default:
3955 rb_bug("vm_weak_table_gen_fields_foreach: return value %d not supported", ivar_ret);
3956 }
3957 }
3958
3959 if (key != new_key || value != new_value) {
3960 DURING_GC_COULD_MALLOC_REGION_START();
3961 {
3962 st_insert(rb_generic_fields_tbl_get(), (st_data_t)new_key, new_value);
3963 }
3964 DURING_GC_COULD_MALLOC_REGION_END();
3965 }
3966
3967 return ret;
3968}
3969
3970static int
3971vm_weak_table_frozen_strings_foreach(VALUE *str, void *data)
3972{
3973 // int retval = vm_weak_table_foreach_weak_key(key, value, data, error);
3974 struct global_vm_table_foreach_data *iter_data = (struct global_vm_table_foreach_data *)data;
3975 int retval = iter_data->callback(*str, iter_data->data);
3976
3977 if (retval == ST_REPLACE) {
3978 retval = iter_data->update_callback(str, iter_data->data);
3979 }
3980
3981 if (retval == ST_DELETE) {
3982 FL_UNSET(*str, RSTRING_FSTR);
3983 }
3984
3985 return retval;
3986}
3987
3988void rb_fstring_foreach_with_replace(int (*callback)(VALUE *str, void *data), void *data);
3989void
3990rb_gc_vm_weak_table_foreach(vm_table_foreach_callback_func callback,
3991 vm_table_update_callback_func update_callback,
3992 void *data,
3993 bool weak_only,
3994 enum rb_gc_vm_weak_tables table)
3995{
3996 rb_vm_t *vm = GET_VM();
3997
3998 struct global_vm_table_foreach_data foreach_data = {
3999 .callback = callback,
4000 .update_callback = update_callback,
4001 .data = data,
4002 .weak_only = weak_only,
4003 };
4004
4005 switch (table) {
4006 case RB_GC_VM_CI_TABLE: {
4007 if (vm->ci_table) {
4008 st_foreach_with_replace(
4009 vm->ci_table,
4010 vm_weak_table_foreach_weak_key,
4011 vm_weak_table_foreach_update_weak_key,
4012 (st_data_t)&foreach_data
4013 );
4014 }
4015 break;
4016 }
4017 case RB_GC_VM_OVERLOADED_CME_TABLE: {
4018 if (vm->overloaded_cme_table) {
4019 st_foreach_with_replace(
4020 vm->overloaded_cme_table,
4021 vm_weak_table_foreach_weak_key,
4022 vm_weak_table_foreach_update_weak_key,
4023 (st_data_t)&foreach_data
4024 );
4025 }
4026 break;
4027 }
4028 case RB_GC_VM_GLOBAL_SYMBOLS_TABLE: {
4029 rb_sym_global_symbol_table_foreach_weak_reference(
4030 vm_weak_table_sym_set_foreach,
4031 &foreach_data
4032 );
4033 break;
4034 }
4035 case RB_GC_VM_ID2REF_TABLE: {
4036 if (id2ref_tbl) {
4037 st_foreach_with_replace(
4038 id2ref_tbl,
4039 vm_weak_table_id2ref_foreach,
4040 vm_weak_table_id2ref_foreach_update,
4041 (st_data_t)&foreach_data
4042 );
4043 }
4044 break;
4045 }
4046 case RB_GC_VM_GENERIC_FIELDS_TABLE: {
4047 st_table *generic_fields_tbl = rb_generic_fields_tbl_get();
4048 if (generic_fields_tbl) {
4049 st_foreach(
4050 generic_fields_tbl,
4051 vm_weak_table_gen_fields_foreach,
4052 (st_data_t)&foreach_data
4053 );
4054 }
4055 break;
4056 }
4057 case RB_GC_VM_FROZEN_STRINGS_TABLE: {
4058 rb_fstring_foreach_with_replace(
4059 vm_weak_table_frozen_strings_foreach,
4060 &foreach_data
4061 );
4062 break;
4063 }
4064 case RB_GC_VM_CC_REFINEMENT_TABLE: {
4065 if (vm->cc_refinement_table) {
4066 set_foreach_with_replace(
4067 vm->cc_refinement_table,
4068 vm_weak_table_cc_refinement_foreach,
4069 vm_weak_table_cc_refinement_foreach_update_update,
4070 (st_data_t)&foreach_data
4071 );
4072 }
4073 break;
4074 }
4075 case RB_GC_VM_WEAK_TABLE_COUNT:
4076 rb_bug("Unreachable");
4077 default:
4078 rb_bug("rb_gc_vm_weak_table_foreach: unknown table %d", table);
4079 }
4080}
4081
4082void
4083rb_gc_update_vm_references(void *objspace)
4084{
4085 rb_execution_context_t *ec = GET_EC();
4086 rb_vm_t *vm = rb_ec_vm_ptr(ec);
4087
4088 rb_vm_update_references(vm);
4089 rb_gc_update_global_tbl();
4090 rb_sym_global_symbols_mark_and_move();
4091
4092#if USE_YJIT
4093 void rb_yjit_root_update_references(void); // in Rust
4094
4095 if (rb_yjit_enabled_p) {
4096 rb_yjit_root_update_references();
4097 }
4098#endif
4099
4100#if USE_ZJIT
4101 void rb_zjit_root_update_references(void); // in Rust
4102
4103 if (rb_zjit_enabled_p) {
4104 rb_zjit_root_update_references();
4105 }
4106#endif
4107}
4108
4109void
4110rb_gc_update_object_references(void *objspace, VALUE obj)
4111{
4112 struct classext_foreach_args args;
4113
4114 switch (BUILTIN_TYPE(obj)) {
4115 case T_CLASS:
4116 if (FL_TEST_RAW(obj, FL_SINGLETON)) {
4117 UPDATE_IF_MOVED(objspace, RCLASS_ATTACHED_OBJECT(obj));
4118 }
4119 // Continue to the shared T_CLASS/T_MODULE
4120 case T_MODULE:
4121 args.klass = obj;
4122 args.objspace = objspace;
4123 rb_class_classext_foreach(obj, update_classext, (void *)&args);
4124 break;
4125
4126 case T_ICLASS:
4127 args.objspace = objspace;
4128 rb_class_classext_foreach(obj, update_iclass_classext, (void *)&args);
4129 break;
4130
4131 case T_IMEMO:
4132 rb_imemo_mark_and_move(obj, true);
4133 return;
4134
4135 case T_NIL:
4136 case T_FIXNUM:
4137 case T_NODE:
4138 case T_MOVED:
4139 case T_NONE:
4140 /* These can't move */
4141 return;
4142
4143 case T_ARRAY:
4144 gc_ref_update_array(objspace, obj);
4145 break;
4146
4147 case T_HASH:
4148 gc_ref_update_hash(objspace, obj);
4149 UPDATE_IF_MOVED(objspace, RHASH(obj)->ifnone);
4150 break;
4151
4152 case T_STRING:
4153 {
4154 if (STR_SHARED_P(obj)) {
4155 UPDATE_IF_MOVED(objspace, RSTRING(obj)->as.heap.aux.shared);
4156 }
4157
4158 /* If, after move the string is not embedded, and can fit in the
4159 * slot it's been placed in, then re-embed it. Skip pinned objects:
4160 * a local holding RSTRING_PTR across this compaction could otherwise
4161 * point to freed memory even if the String is marked and pinned. */
4162 if (rb_gc_obj_slot_size(obj) >= rb_str_size_as_embedded(obj)) {
4163 if (!STR_EMBED_P(obj) && rb_str_reembeddable_p(obj)
4164 && !rb_gc_impl_pinned_p(objspace, obj)) {
4165 rb_str_make_embedded(obj);
4166 }
4167 }
4168
4169 break;
4170 }
4171 case T_DATA:
4172 /* Call the compaction callback, if it exists */
4173 {
4174 bool typed_data = RTYPEDDATA_P(obj);
4175 void *const ptr = typed_data ? RTYPEDDATA_GET_DATA(obj) : DATA_PTR(obj);
4176
4177 if (typed_data) {
4178 UPDATE_IF_MOVED(objspace, RTYPEDDATA(obj)->fields_obj);
4179 }
4180
4181 if (ptr) {
4182 if (typed_data && gc_declarative_marking_p(RTYPEDDATA_TYPE(obj))) {
4183 size_t *offset_list = TYPED_DATA_REFS_OFFSET_LIST(obj);
4184
4185 for (size_t offset = *offset_list; offset != RUBY_REF_END; offset = *offset_list++) {
4186 VALUE *ref = (VALUE *)((char *)ptr + offset);
4187 *ref = gc_location_internal(objspace, *ref);
4188 }
4189 }
4190 else if (typed_data) {
4191 RUBY_DATA_FUNC compact_func = RTYPEDDATA_TYPE(obj)->function.dcompact;
4192 if (compact_func) (*compact_func)(ptr);
4193 }
4194 }
4195 }
4196 break;
4197
4198 case T_OBJECT:
4199 gc_ref_update_object(objspace, obj);
4200 break;
4201
4202 case T_FILE:
4203 if (RFILE(obj)->fptr) {
4204 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->self);
4205 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->pathv);
4206 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->tied_io_for_writing);
4207 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->writeconv_asciicompat);
4208 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->writeconv_pre_ecopts);
4209 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->encs.ecopts);
4210 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->write_lock);
4211 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->timeout);
4212 UPDATE_IF_MOVED(objspace, RFILE(obj)->fptr->wakeup_mutex);
4213 }
4214 break;
4215 case T_REGEXP:
4216 UPDATE_IF_MOVED(objspace, RREGEXP(obj)->src);
4217 break;
4218
4219 case T_SYMBOL:
4220 UPDATE_IF_MOVED(objspace, RSYMBOL(obj)->fstr);
4221 break;
4222
4223 case T_FLOAT:
4224 case T_BIGNUM:
4225 break;
4226
4227 case T_MATCH:
4228 UPDATE_IF_MOVED(objspace, RMATCH(obj)->regexp);
4229
4230 if (RMATCH(obj)->str) {
4231 UPDATE_IF_MOVED(objspace, RMATCH(obj)->str);
4232 }
4233 break;
4234
4235 case T_RATIONAL:
4236 UPDATE_IF_MOVED(objspace, RRATIONAL(obj)->num);
4237 UPDATE_IF_MOVED(objspace, RRATIONAL(obj)->den);
4238 break;
4239
4240 case T_COMPLEX:
4241 UPDATE_IF_MOVED(objspace, RCOMPLEX(obj)->real);
4242 UPDATE_IF_MOVED(objspace, RCOMPLEX(obj)->imag);
4243
4244 break;
4245
4246 case T_STRUCT:
4247 {
4248 long i, len = RSTRUCT_LEN(obj);
4249 VALUE *ptr = (VALUE *)RSTRUCT_CONST_PTR(obj);
4250
4251 for (i = 0; i < len; i++) {
4252 UPDATE_IF_MOVED(objspace, ptr[i]);
4253 }
4254
4255 if (RSTRUCT_EMBED_LEN(obj)) {
4256 if (!FL_TEST_RAW(obj, RSTRUCT_GEN_FIELDS)) {
4257 UPDATE_IF_MOVED(objspace, ptr[len]);
4258 }
4259 }
4260 else {
4261 UPDATE_IF_MOVED(objspace, RSTRUCT(obj)->as.heap.fields_obj);
4262 }
4263 }
4264 break;
4265 default:
4266 rb_bug("unreachable");
4267 break;
4268 }
4269
4270 UPDATE_IF_MOVED(objspace, RBASIC(obj)->klass);
4271}
4272
4273VALUE
4274rb_gc_start(void)
4275{
4276 rb_gc();
4277 return Qnil;
4278}
4279
4280void
4281rb_gc(void)
4282{
4283 unless_objspace(objspace) { return; }
4284
4285 rb_gc_impl_start(objspace, true, true, true, false);
4286}
4287
4288int
4289rb_during_gc(void)
4290{
4291 unless_objspace(objspace) { return FALSE; }
4292
4293 return rb_gc_impl_during_gc_p(objspace);
4294}
4295
4296size_t
4297rb_gc_count(void)
4298{
4299 return rb_gc_impl_gc_count(rb_gc_get_objspace());
4300}
4301
4302static VALUE
4303gc_count(rb_execution_context_t *ec, VALUE self)
4304{
4305 return SIZET2NUM(rb_gc_count());
4306}
4307
4308VALUE
4309rb_gc_latest_gc_info(VALUE key)
4310{
4311 if (!SYMBOL_P(key) && !RB_TYPE_P(key, T_HASH)) {
4312 rb_raise(rb_eTypeError, "non-hash or symbol given");
4313 }
4314
4315 VALUE val = rb_gc_impl_latest_gc_info(rb_gc_get_objspace(), key);
4316
4317 if (val == Qundef) {
4318 rb_raise(rb_eArgError, "unknown key: %"PRIsVALUE, rb_sym2str(key));
4319 }
4320
4321 return val;
4322}
4323
4324static VALUE
4325gc_stat(rb_execution_context_t *ec, VALUE self, VALUE arg) // arg is (nil || hash || symbol)
4326{
4327 if (NIL_P(arg)) {
4328 arg = rb_hash_new();
4329 }
4330 else if (!RB_TYPE_P(arg, T_HASH) && !SYMBOL_P(arg)) {
4331 rb_raise(rb_eTypeError, "non-hash or symbol given");
4332 }
4333
4334 VALUE ret = rb_gc_impl_stat(rb_gc_get_objspace(), arg);
4335
4336 if (ret == Qundef) {
4337 GC_ASSERT(SYMBOL_P(arg));
4338
4339 rb_raise(rb_eArgError, "unknown key: %"PRIsVALUE, rb_sym2str(arg));
4340 }
4341
4342 return ret;
4343}
4344
4345size_t
4346rb_gc_stat(VALUE arg)
4347{
4348 if (!RB_TYPE_P(arg, T_HASH) && !SYMBOL_P(arg)) {
4349 rb_raise(rb_eTypeError, "non-hash or symbol given");
4350 }
4351
4352 VALUE ret = rb_gc_impl_stat(rb_gc_get_objspace(), arg);
4353
4354 if (ret == Qundef) {
4355 GC_ASSERT(SYMBOL_P(arg));
4356
4357 rb_raise(rb_eArgError, "unknown key: %"PRIsVALUE, rb_sym2str(arg));
4358 }
4359
4360 if (SYMBOL_P(arg)) {
4361 return NUM2SIZET(ret);
4362 }
4363 else {
4364 return 0;
4365 }
4366}
4367
4368static VALUE
4369gc_stat_heap(rb_execution_context_t *ec, VALUE self, VALUE heap_name, VALUE arg)
4370{
4371 if (NIL_P(arg)) {
4372 arg = rb_hash_new();
4373 }
4374
4375 if (NIL_P(heap_name)) {
4376 if (!RB_TYPE_P(arg, T_HASH)) {
4377 rb_raise(rb_eTypeError, "non-hash given");
4378 }
4379 }
4380 else if (FIXNUM_P(heap_name)) {
4381 if (!SYMBOL_P(arg) && !RB_TYPE_P(arg, T_HASH)) {
4382 rb_raise(rb_eTypeError, "non-hash or symbol given");
4383 }
4384 }
4385 else {
4386 rb_raise(rb_eTypeError, "heap_name must be nil or an Integer");
4387 }
4388
4389 VALUE ret = rb_gc_impl_stat_heap(rb_gc_get_objspace(), heap_name, arg);
4390
4391 if (ret == Qundef) {
4392 GC_ASSERT(SYMBOL_P(arg));
4393
4394 rb_raise(rb_eArgError, "unknown key: %"PRIsVALUE, rb_sym2str(arg));
4395 }
4396
4397 return ret;
4398}
4399
4400static VALUE
4401gc_config_get(rb_execution_context_t *ec, VALUE self)
4402{
4403 VALUE cfg_hash = rb_gc_impl_config_get(rb_gc_get_objspace());
4404 rb_hash_aset(cfg_hash, sym("implementation"), rb_fstring_cstr(rb_gc_impl_active_gc_name()));
4405
4406 return cfg_hash;
4407}
4408
4409static VALUE
4410gc_config_set(rb_execution_context_t *ec, VALUE self, VALUE hash)
4411{
4412 void *objspace = rb_gc_get_objspace();
4413
4414 rb_gc_impl_config_set(objspace, hash);
4415
4416 return Qnil;
4417}
4418
4419static VALUE
4420gc_stress_get(rb_execution_context_t *ec, VALUE self)
4421{
4422 return rb_gc_impl_stress_get(rb_gc_get_objspace());
4423}
4424
4425static VALUE
4426gc_stress_set_m(rb_execution_context_t *ec, VALUE self, VALUE flag)
4427{
4428 rb_gc_impl_stress_set(rb_gc_get_objspace(), flag);
4429
4430 return flag;
4431}
4432
4433void
4434rb_gc_initial_stress_set(VALUE flag)
4435{
4436 initial_stress = flag;
4437}
4438
4439size_t *
4440rb_gc_heap_sizes(void)
4441{
4442 return rb_gc_impl_heap_sizes(rb_gc_get_objspace());
4443}
4444
4445VALUE
4446rb_gc_enable(void)
4447{
4448 return rb_objspace_gc_enable(rb_gc_get_objspace());
4449}
4450
4451VALUE
4452rb_objspace_gc_enable(void *objspace)
4453{
4454 bool disabled = !rb_gc_impl_gc_enabled_p(objspace);
4455 rb_gc_impl_gc_enable(objspace);
4456 return RBOOL(disabled);
4457}
4458
4459static VALUE
4460gc_enable(rb_execution_context_t *ec, VALUE _)
4461{
4462 return rb_gc_enable();
4463}
4464
4465static VALUE
4466gc_disable_no_rest(void *objspace)
4467{
4468 bool disabled = !rb_gc_impl_gc_enabled_p(objspace);
4469 rb_gc_impl_gc_disable(objspace, false);
4470 return RBOOL(disabled);
4471}
4472
4473VALUE
4474rb_gc_disable_no_rest(void)
4475{
4476 return gc_disable_no_rest(rb_gc_get_objspace());
4477}
4478
4479VALUE
4480rb_gc_disable(void)
4481{
4482 return rb_objspace_gc_disable(rb_gc_get_objspace());
4483}
4484
4485VALUE
4486rb_objspace_gc_disable(void *objspace)
4487{
4488 bool disabled = !rb_gc_impl_gc_enabled_p(objspace);
4489 rb_gc_impl_gc_disable(objspace, true);
4490 return RBOOL(disabled);
4491}
4492
4493static VALUE
4494gc_disable(rb_execution_context_t *ec, VALUE _)
4495{
4496 return rb_gc_disable();
4497}
4498
4499// TODO: think about moving ruby_gc_set_params into Init_heap or Init_gc
4500void
4501ruby_gc_set_params(void)
4502{
4503 rb_gc_impl_set_params(rb_gc_get_objspace());
4504}
4505
4506void
4507rb_objspace_reachable_objects_from(VALUE obj, void (func)(VALUE, void *), void *data)
4508{
4509 RB_VM_LOCKING() {
4510 if (rb_gc_impl_during_gc_p(rb_gc_get_objspace())) rb_bug("rb_objspace_reachable_objects_from() is not supported while during GC");
4511
4512 if (!RB_SPECIAL_CONST_P(obj)) {
4513 rb_vm_t *vm = GET_VM();
4514 struct gc_mark_func_data_struct *prev_mfd = vm->gc.mark_func_data;
4515 struct gc_mark_func_data_struct mfd = {
4516 .mark_func = func,
4517 .data = data,
4518 };
4519
4520 vm->gc.mark_func_data = &mfd;
4521 rb_gc_mark_children(rb_gc_get_objspace(), obj);
4522 vm->gc.mark_func_data = prev_mfd;
4523 }
4524 }
4525}
4526
4528 const char *category;
4529 void (*func)(const char *category, VALUE, void *);
4530 void *data;
4531};
4532
4533static void
4534root_objects_from(VALUE obj, void *ptr)
4535{
4536 const struct root_objects_data *data = (struct root_objects_data *)ptr;
4537 (*data->func)(data->category, obj, data->data);
4538}
4539
4540void
4541rb_objspace_reachable_objects_from_root(void (func)(const char *category, VALUE, void *), void *passing_data)
4542{
4543 if (rb_gc_impl_during_gc_p(rb_gc_get_objspace())) rb_bug("rb_gc_impl_objspace_reachable_objects_from_root() is not supported while during GC");
4544
4545 rb_vm_t *vm = GET_VM();
4546
4547 struct root_objects_data data = {
4548 .func = func,
4549 .data = passing_data,
4550 };
4551
4552 struct gc_mark_func_data_struct *prev_mfd = vm->gc.mark_func_data;
4553 struct gc_mark_func_data_struct mfd = {
4554 .mark_func = root_objects_from,
4555 .data = &data,
4556 };
4557
4558 vm->gc.mark_func_data = &mfd;
4559 rb_gc_save_machine_context();
4560 rb_gc_mark_roots(vm->gc.objspace, &data.category);
4561 vm->gc.mark_func_data = prev_mfd;
4562}
4563
4564/*
4565 ------------------------------ DEBUG ------------------------------
4566*/
4567
4568static const char *
4569type_name(int type, VALUE obj)
4570{
4571 switch (type) {
4572#define TYPE_NAME(t) case (t): return #t;
4573 TYPE_NAME(T_NONE);
4574 TYPE_NAME(T_OBJECT);
4575 TYPE_NAME(T_CLASS);
4576 TYPE_NAME(T_MODULE);
4577 TYPE_NAME(T_FLOAT);
4578 TYPE_NAME(T_STRING);
4579 TYPE_NAME(T_REGEXP);
4580 TYPE_NAME(T_ARRAY);
4581 TYPE_NAME(T_HASH);
4582 TYPE_NAME(T_STRUCT);
4583 TYPE_NAME(T_BIGNUM);
4584 TYPE_NAME(T_FILE);
4585 TYPE_NAME(T_MATCH);
4586 TYPE_NAME(T_COMPLEX);
4587 TYPE_NAME(T_RATIONAL);
4588 TYPE_NAME(T_NIL);
4589 TYPE_NAME(T_TRUE);
4590 TYPE_NAME(T_FALSE);
4591 TYPE_NAME(T_SYMBOL);
4592 TYPE_NAME(T_FIXNUM);
4593 TYPE_NAME(T_UNDEF);
4594 TYPE_NAME(T_IMEMO);
4595 TYPE_NAME(T_ICLASS);
4596 TYPE_NAME(T_MOVED);
4597 TYPE_NAME(T_ZOMBIE);
4598 case T_DATA:
4599 if (obj && rb_objspace_data_type_name(obj)) {
4600 return rb_objspace_data_type_name(obj);
4601 }
4602 return "T_DATA";
4603#undef TYPE_NAME
4604 }
4605 return "unknown";
4606}
4607
4608static const char *
4609obj_type_name(VALUE obj)
4610{
4611 return type_name(TYPE(obj), obj);
4612}
4613
4614const char *
4615rb_method_type_name(rb_method_type_t type)
4616{
4617 switch (type) {
4618 case VM_METHOD_TYPE_ISEQ: return "iseq";
4619 case VM_METHOD_TYPE_ATTRSET: return "attrest";
4620 case VM_METHOD_TYPE_IVAR: return "ivar";
4621 case VM_METHOD_TYPE_BMETHOD: return "bmethod";
4622 case VM_METHOD_TYPE_ALIAS: return "alias";
4623 case VM_METHOD_TYPE_REFINED: return "refined";
4624 case VM_METHOD_TYPE_CFUNC: return "cfunc";
4625 case VM_METHOD_TYPE_ZSUPER: return "zsuper";
4626 case VM_METHOD_TYPE_MISSING: return "missing";
4627 case VM_METHOD_TYPE_OPTIMIZED: return "optimized";
4628 case VM_METHOD_TYPE_UNDEF: return "undef";
4629 case VM_METHOD_TYPE_NOTIMPLEMENTED: return "notimplemented";
4630 }
4631 rb_bug("rb_method_type_name: unreachable (type: %d)", type);
4632}
4633
4634static void
4635rb_raw_iseq_info(char *const buff, const size_t buff_size, const rb_iseq_t *iseq)
4636{
4637 if (buff_size > 0 && ISEQ_BODY(iseq) && ISEQ_BODY(iseq)->location.label && !RB_TYPE_P(ISEQ_BODY(iseq)->location.pathobj, T_MOVED)) {
4638 VALUE path = rb_iseq_path(iseq);
4639 int n = ISEQ_BODY(iseq)->location.first_lineno;
4640 snprintf(buff, buff_size, " %s@%s:%d",
4641 RSTRING_PTR(ISEQ_BODY(iseq)->location.label),
4642 RSTRING_PTR(path), n);
4643 }
4644}
4645
4646static int
4647str_len_no_raise(VALUE str)
4648{
4649 long len = RSTRING_LEN(str);
4650 if (len < 0) return 0;
4651 if (len > INT_MAX) return INT_MAX;
4652 return (int)len;
4653}
4654
4655#define BUFF_ARGS buff + pos, buff_size - pos
4656#define APPEND_F(...) if ((pos += snprintf(BUFF_ARGS, "" __VA_ARGS__)) >= buff_size) goto end
4657#define APPEND_S(s) do { \
4658 if ((pos + (int)rb_strlen_lit(s)) >= buff_size) { \
4659 goto end; \
4660 } \
4661 else { \
4662 memcpy(buff + pos, (s), rb_strlen_lit(s) + 1); \
4663 } \
4664 } while (0)
4665#define C(c, s) ((c) != 0 ? (s) : " ")
4666
4667static size_t
4668rb_raw_obj_info_common(char *const buff, const size_t buff_size, const VALUE obj)
4669{
4670 size_t pos = 0;
4671
4672 if (SPECIAL_CONST_P(obj)) {
4673 APPEND_F("%s", obj_type_name(obj));
4674
4675 if (FIXNUM_P(obj)) {
4676 APPEND_F(" %ld", FIX2LONG(obj));
4677 }
4678 else if (SYMBOL_P(obj)) {
4679 APPEND_F(" %s", rb_id2name(SYM2ID(obj)));
4680 }
4681 }
4682 else {
4683 // const int age = RVALUE_AGE_GET(obj);
4684
4685 if (rb_gc_impl_pointer_to_heap_p(rb_gc_get_objspace(), (void *)obj)) {
4686 APPEND_F("%p %s/", (void *)obj, obj_type_name(obj));
4687 // TODO: fixme
4688 // APPEND_F("%p [%d%s%s%s%s%s%s] %s ",
4689 // (void *)obj, age,
4690 // C(RVALUE_UNCOLLECTIBLE_BITMAP(obj), "L"),
4691 // C(RVALUE_MARK_BITMAP(obj), "M"),
4692 // C(RVALUE_PIN_BITMAP(obj), "P"),
4693 // C(RVALUE_MARKING_BITMAP(obj), "R"),
4694 // C(RVALUE_WB_UNPROTECTED_BITMAP(obj), "U"),
4695 // C(rb_objspace_garbage_object_p(obj), "G"),
4696 // obj_type_name(obj));
4697 }
4698 else {
4699 /* fake */
4700 // APPEND_F("%p [%dXXXX] %s",
4701 // (void *)obj, age,
4702 // obj_type_name(obj));
4703 }
4704
4705 if (internal_object_p(obj)) {
4706 /* ignore */
4707 }
4708 else if (RBASIC(obj)->klass == 0) {
4709 APPEND_S("(temporary internal)");
4710 }
4711 else if (RTEST(RBASIC(obj)->klass)) {
4712 VALUE class_path = rb_class_path_cached(RBASIC(obj)->klass);
4713 if (!NIL_P(class_path)) {
4714 APPEND_F("%s ", RSTRING_PTR(class_path));
4715 }
4716 }
4717 }
4718 end:
4719
4720 return pos;
4721}
4722
4723const char *rb_raw_obj_info(char *const buff, const size_t buff_size, VALUE obj);
4724
4725static size_t
4726rb_raw_obj_info_buitin_type(char *const buff, const size_t buff_size, const VALUE obj, size_t pos)
4727{
4728 if (LIKELY(pos < buff_size) && !SPECIAL_CONST_P(obj)) {
4729 const enum ruby_value_type type = BUILTIN_TYPE(obj);
4730
4731 switch (type) {
4732 case T_NODE:
4733 UNEXPECTED_NODE(rb_raw_obj_info);
4734 break;
4735 case T_ARRAY:
4736 if (ARY_SHARED_P(obj)) {
4737 APPEND_S("shared -> ");
4738 rb_raw_obj_info(BUFF_ARGS, ARY_SHARED_ROOT(obj));
4739 }
4740 else {
4741 APPEND_F("[%s%s%s] ",
4742 C(ARY_EMBED_P(obj), "E"),
4743 C(ARY_SHARED_P(obj), "S"),
4744 C(ARY_SHARED_ROOT_P(obj), "R"));
4745
4746 if (ARY_EMBED_P(obj)) {
4747 APPEND_F("len: %ld (embed)",
4748 RARRAY_LEN(obj));
4749 }
4750 else {
4751 APPEND_F("len: %ld, capa:%ld ptr:%p",
4752 RARRAY_LEN(obj),
4753 RARRAY(obj)->as.heap.aux.capa,
4754 (void *)RARRAY_CONST_PTR(obj));
4755 }
4756 }
4757 break;
4758 case T_STRING: {
4759 if (STR_SHARED_P(obj)) {
4760 APPEND_F(" [shared] len: %ld", RSTRING_LEN(obj));
4761 }
4762 else {
4763 if (STR_EMBED_P(obj)) APPEND_S(" [embed]");
4764
4765 APPEND_F(" len: %ld, capa: %" PRIdSIZE, RSTRING_LEN(obj), rb_str_capacity(obj));
4766 }
4767 APPEND_F(" \"%.*s\"", str_len_no_raise(obj), RSTRING_PTR(obj));
4768 break;
4769 }
4770 case T_SYMBOL: {
4771 VALUE fstr = RSYMBOL(obj)->fstr;
4772 ID id = RSYMBOL(obj)->id;
4773 if (RB_TYPE_P(fstr, T_STRING)) {
4774 APPEND_F(":%s id:%d", RSTRING_PTR(fstr), (unsigned int)id);
4775 }
4776 else {
4777 APPEND_F("(%p) id:%d", (void *)fstr, (unsigned int)id);
4778 }
4779 break;
4780 }
4781 case T_MOVED: {
4782 APPEND_F("-> %p", (void*)gc_location_internal(rb_gc_get_objspace(), obj));
4783 break;
4784 }
4785 case T_HASH: {
4786 APPEND_F("[%c] %"PRIdSIZE,
4787 RHASH_AR_TABLE_P(obj) ? 'A' : 'S',
4788 RHASH_SIZE(obj));
4789 break;
4790 }
4791 case T_CLASS:
4792 case T_MODULE:
4793 {
4794 VALUE class_path = rb_class_path_cached(obj);
4795 if (!NIL_P(class_path)) {
4796 APPEND_F("%s", RSTRING_PTR(class_path));
4797 }
4798 else {
4799 APPEND_S("(anon)");
4800 }
4801 break;
4802 }
4803 case T_ICLASS:
4804 {
4805 VALUE class_path = rb_class_path_cached(RBASIC_CLASS(obj));
4806 if (!NIL_P(class_path)) {
4807 APPEND_F("src:%s", RSTRING_PTR(class_path));
4808 }
4809 break;
4810 }
4811 case T_OBJECT:
4812 {
4813 if (FL_TEST_RAW(obj, ROBJECT_HEAP)) {
4814 if (rb_shape_obj_too_complex_p(obj)) {
4815 size_t hash_len = rb_st_table_size(ROBJECT_FIELDS_HASH(obj));
4816 APPEND_F("(too_complex) len:%zu", hash_len);
4817 }
4818 else {
4819 APPEND_F("(embed) len:%d capa:%d", RSHAPE_LEN(RBASIC_SHAPE_ID(obj)), ROBJECT_FIELDS_CAPACITY(obj));
4820 }
4821 }
4822 else {
4823 APPEND_F("len:%d capa:%d ptr:%p", RSHAPE_LEN(RBASIC_SHAPE_ID(obj)), ROBJECT_FIELDS_CAPACITY(obj), (void *)ROBJECT_FIELDS(obj));
4824 }
4825 }
4826 break;
4827 case T_DATA: {
4828 const struct rb_block *block;
4829 const rb_iseq_t *iseq;
4830 if (rb_obj_is_proc(obj) &&
4831 (block = vm_proc_block(obj)) != NULL &&
4832 (vm_block_type(block) == block_type_iseq) &&
4833 (iseq = vm_block_iseq(block)) != NULL) {
4834 rb_raw_iseq_info(BUFF_ARGS, iseq);
4835 }
4836 else if (rb_ractor_p(obj)) {
4837 rb_ractor_t *r = (void *)DATA_PTR(obj);
4838 if (r) {
4839 APPEND_F("r:%d", r->pub.id);
4840 }
4841 }
4842 else {
4843 const char * const type_name = rb_objspace_data_type_name(obj);
4844 if (type_name) {
4845 APPEND_F("%s", type_name);
4846 }
4847 }
4848 break;
4849 }
4850 case T_IMEMO: {
4851 APPEND_F("<%s> ", rb_imemo_name(imemo_type(obj)));
4852
4853 switch (imemo_type(obj)) {
4854 case imemo_ment:
4855 {
4856 const rb_method_entry_t *me = (const rb_method_entry_t *)obj;
4857
4858 APPEND_F(":%s (%s%s%s%s) type:%s aliased:%d owner:%p defined_class:%p",
4859 rb_id2name(me->called_id),
4860 METHOD_ENTRY_VISI(me) == METHOD_VISI_PUBLIC ? "pub" :
4861 METHOD_ENTRY_VISI(me) == METHOD_VISI_PRIVATE ? "pri" : "pro",
4862 METHOD_ENTRY_COMPLEMENTED(me) ? ",cmp" : "",
4863 METHOD_ENTRY_CACHED(me) ? ",cc" : "",
4864 METHOD_ENTRY_INVALIDATED(me) ? ",inv" : "",
4865 me->def ? rb_method_type_name(me->def->type) : "NULL",
4866 me->def ? me->def->aliased : -1,
4867 (void *)me->owner, // obj_info(me->owner),
4868 (void *)me->defined_class); //obj_info(me->defined_class)));
4869
4870 if (me->def) {
4871 switch (me->def->type) {
4872 case VM_METHOD_TYPE_ISEQ:
4873 APPEND_S(" (iseq:");
4874 rb_raw_obj_info(BUFF_ARGS, (VALUE)me->def->body.iseq.iseqptr);
4875 APPEND_S(")");
4876 break;
4877 default:
4878 break;
4879 }
4880 }
4881
4882 break;
4883 }
4884 case imemo_iseq: {
4885 const rb_iseq_t *iseq = (const rb_iseq_t *)obj;
4886 rb_raw_iseq_info(BUFF_ARGS, iseq);
4887 break;
4888 }
4889 case imemo_callinfo:
4890 {
4891 const struct rb_callinfo *ci = (const struct rb_callinfo *)obj;
4892 APPEND_F("(mid:%s, flag:%x argc:%d, kwarg:%s)",
4893 rb_id2name(vm_ci_mid(ci)),
4894 vm_ci_flag(ci),
4895 vm_ci_argc(ci),
4896 vm_ci_kwarg(ci) ? "available" : "NULL");
4897 break;
4898 }
4899 case imemo_callcache:
4900 {
4901 const struct rb_callcache *cc = (const struct rb_callcache *)obj;
4902 VALUE class_path = vm_cc_valid(cc) ? rb_class_path_cached(cc->klass) : Qnil;
4903 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
4904
4905 APPEND_F("(klass:%s cme:%s%s (%p) call:%p",
4906 NIL_P(class_path) ? (vm_cc_valid(cc) ? "??" : "<NULL>") : RSTRING_PTR(class_path),
4907 cme ? rb_id2name(cme->called_id) : "<NULL>",
4908 cme ? (METHOD_ENTRY_INVALIDATED(cme) ? " [inv]" : "") : "",
4909 (void *)cme,
4910 (void *)(uintptr_t)vm_cc_call(cc));
4911 break;
4912 }
4913 default:
4914 break;
4915 }
4916 }
4917 default:
4918 break;
4919 }
4920 }
4921 end:
4922
4923 return pos;
4924}
4925
4926#undef C
4927
4928#ifdef RUBY_ASAN_ENABLED
4929void
4930rb_asan_poison_object(VALUE obj)
4931{
4932 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
4933 asan_poison_memory_region(ptr, rb_gc_obj_slot_size(obj));
4934}
4935
4936void
4937rb_asan_unpoison_object(VALUE obj, bool newobj_p)
4938{
4939 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
4940 asan_unpoison_memory_region(ptr, rb_gc_obj_slot_size(obj), newobj_p);
4941}
4942
4943void *
4944rb_asan_poisoned_object_p(VALUE obj)
4945{
4946 MAYBE_UNUSED(struct RVALUE *) ptr = (void *)obj;
4947 return __asan_region_is_poisoned(ptr, rb_gc_obj_slot_size(obj));
4948}
4949#endif
4950
4951static void
4952raw_obj_info(char *const buff, const size_t buff_size, VALUE obj)
4953{
4954 size_t pos = rb_raw_obj_info_common(buff, buff_size, obj);
4955 pos = rb_raw_obj_info_buitin_type(buff, buff_size, obj, pos);
4956 if (pos >= buff_size) {} // truncated
4957}
4958
4959const char *
4960rb_raw_obj_info(char *const buff, const size_t buff_size, VALUE obj)
4961{
4962 void *objspace = rb_gc_get_objspace();
4963
4964 if (SPECIAL_CONST_P(obj)) {
4965 raw_obj_info(buff, buff_size, obj);
4966 }
4967 else if (!rb_gc_impl_pointer_to_heap_p(objspace, (const void *)obj)) {
4968 snprintf(buff, buff_size, "out-of-heap:%p", (void *)obj);
4969 }
4970#if 0 // maybe no need to check it?
4971 else if (0 && rb_gc_impl_garbage_object_p(objspace, obj)) {
4972 snprintf(buff, buff_size, "garbage:%p", (void *)obj);
4973 }
4974#endif
4975 else {
4976 asan_unpoisoning_object(obj) {
4977 raw_obj_info(buff, buff_size, obj);
4978 }
4979 }
4980 return buff;
4981}
4982
4983#undef APPEND_S
4984#undef APPEND_F
4985#undef BUFF_ARGS
4986
4987/* Increments *var atomically and resets *var to 0 when maxval is
4988 * reached. Returns the wraparound old *var value (0...maxval). */
4989static rb_atomic_t
4990atomic_inc_wraparound(rb_atomic_t *var, const rb_atomic_t maxval)
4991{
4992 rb_atomic_t oldval = RUBY_ATOMIC_FETCH_ADD(*var, 1);
4993 if (RB_UNLIKELY(oldval >= maxval - 1)) { // wraparound *var
4994 const rb_atomic_t newval = oldval + 1;
4995 RUBY_ATOMIC_CAS(*var, newval, newval % maxval);
4996 oldval %= maxval;
4997 }
4998 return oldval;
4999}
5000
5001static const char *
5002obj_info(VALUE obj)
5003{
5004 if (RGENGC_OBJ_INFO) {
5005 static struct {
5006 rb_atomic_t index;
5007 char buffers[10][0x100];
5008 } info = {0};
5009
5010 rb_atomic_t index = atomic_inc_wraparound(&info.index, numberof(info.buffers));
5011 char *const buff = info.buffers[index];
5012 return rb_raw_obj_info(buff, sizeof(info.buffers[0]), obj);
5013 }
5014 return obj_type_name(obj);
5015}
5016
5017/*
5018 ------------------------ Extended allocator ------------------------
5019*/
5020
5022 VALUE exc;
5023 const char *fmt;
5024 va_list *ap;
5025};
5026
5027static void *
5028gc_vraise(void *ptr)
5029{
5030 struct gc_raise_tag *argv = ptr;
5031 rb_vraise(argv->exc, argv->fmt, *argv->ap);
5032 UNREACHABLE_RETURN(NULL);
5033}
5034
5035static void
5036gc_raise(VALUE exc, const char *fmt, ...)
5037{
5038 va_list ap;
5039 va_start(ap, fmt);
5040 struct gc_raise_tag argv = {
5041 exc, fmt, &ap,
5042 };
5043
5044 if (ruby_native_thread_p()) {
5045 rb_thread_call_with_gvl(gc_vraise, &argv);
5047 }
5048 else {
5049 /* Not in a ruby thread */
5050 fprintf(stderr, "%s", "[FATAL] ");
5051 vfprintf(stderr, fmt, ap);
5052 }
5053
5054 va_end(ap);
5055 abort();
5056}
5057
5058NORETURN(static void negative_size_allocation_error(const char *));
5059static void
5060negative_size_allocation_error(const char *msg)
5061{
5062 gc_raise(rb_eNoMemError, "%s", msg);
5063}
5064
5065static void *
5066ruby_memerror_body(void *dummy)
5067{
5068 rb_memerror();
5069 return 0;
5070}
5071
5072NORETURN(static void ruby_memerror(void));
5074static void
5075ruby_memerror(void)
5076{
5077 if (ruby_thread_has_gvl_p()) {
5078 rb_memerror();
5079 }
5080 else {
5081 if (ruby_native_thread_p()) {
5082 rb_thread_call_with_gvl(ruby_memerror_body, 0);
5083 }
5084 else {
5085 /* no ruby thread */
5086 fprintf(stderr, "[FATAL] failed to allocate memory\n");
5087 }
5088 }
5089
5090 /* We have discussions whether we should die here; */
5091 /* We might rethink about it later. */
5092 exit(EXIT_FAILURE);
5093}
5094
5095void
5096rb_memerror(void)
5097{
5098 /* the `GET_VM()->special_exceptions` below assumes that
5099 * the VM is reachable from the current thread. We should
5100 * definitely make sure of that. */
5101 RUBY_ASSERT_ALWAYS(ruby_thread_has_gvl_p());
5102
5103 rb_execution_context_t *ec = GET_EC();
5104 VALUE exc = GET_VM()->special_exceptions[ruby_error_nomemory];
5105
5106 if (!exc ||
5107 rb_ec_raised_p(ec, RAISED_NOMEMORY) ||
5108 rb_ec_vm_lock_rec(ec) != ec->tag->lock_rec) {
5109 fprintf(stderr, "[FATAL] failed to allocate memory\n");
5110 exit(EXIT_FAILURE);
5111 }
5112 if (rb_ec_raised_p(ec, RAISED_NOMEMORY)) {
5113 rb_ec_raised_clear(ec);
5114 }
5115 else {
5116 rb_ec_raised_set(ec, RAISED_NOMEMORY);
5117 exc = ruby_vm_special_exception_copy(exc);
5118 }
5119 ec->errinfo = exc;
5120 EC_JUMP_TAG(ec, TAG_RAISE);
5121}
5122
5123bool
5124rb_memerror_reentered(void)
5125{
5126 rb_execution_context_t *ec = GET_EC();
5127 return (ec && rb_ec_raised_p(ec, RAISED_NOMEMORY));
5128}
5129
5130static void *
5131handle_malloc_failure(void *ptr)
5132{
5133 if (LIKELY(ptr)) {
5134 return ptr;
5135 }
5136 else {
5137 ruby_memerror();
5139 }
5140}
5141
5142static void *ruby_xmalloc_body(size_t size);
5143
5144void *
5145ruby_xmalloc(size_t size)
5146{
5147 return handle_malloc_failure(ruby_xmalloc_body(size));
5148}
5149
5150static bool
5151malloc_gc_allowed(void)
5152{
5153 rb_ractor_t *r = rb_current_ractor_raw(false);
5154
5155 return r == NULL || !r->malloc_gc_disabled;
5156}
5157
5158static void *
5159ruby_xmalloc_body(size_t size)
5160{
5161 if ((ssize_t)size < 0) {
5162 negative_size_allocation_error("too large allocation size");
5163 }
5164
5165 return rb_gc_impl_malloc(rb_gc_get_objspace(), size, malloc_gc_allowed());
5166}
5167
5168void
5169ruby_malloc_size_overflow(size_t count, size_t elsize)
5170{
5171 rb_raise(rb_eArgError,
5172 "malloc: possible integer overflow (%"PRIuSIZE"*%"PRIuSIZE")",
5173 count, elsize);
5174}
5175
5176void
5177ruby_malloc_add_size_overflow(size_t x, size_t y)
5178{
5179 rb_raise(rb_eArgError,
5180 "malloc: possible integer overflow (%"PRIuSIZE"+%"PRIuSIZE")",
5181 x, y);
5182}
5183
5184static void *ruby_xmalloc2_body(size_t n, size_t size);
5185
5186void *
5187ruby_xmalloc2(size_t n, size_t size)
5188{
5189 return handle_malloc_failure(ruby_xmalloc2_body(n, size));
5190}
5191
5192static void *
5193ruby_xmalloc2_body(size_t n, size_t size)
5194{
5195 return rb_gc_impl_malloc(rb_gc_get_objspace(), xmalloc2_size(n, size), malloc_gc_allowed());
5196}
5197
5198static void *ruby_xcalloc_body(size_t n, size_t size);
5199
5200void *
5201ruby_xcalloc(size_t n, size_t size)
5202{
5203 return handle_malloc_failure(ruby_xcalloc_body(n, size));
5204}
5205
5206static void *
5207ruby_xcalloc_body(size_t n, size_t size)
5208{
5209 return rb_gc_impl_calloc(rb_gc_get_objspace(), xmalloc2_size(n, size), malloc_gc_allowed());
5210}
5211
5212static void *ruby_sized_xrealloc_body(void *ptr, size_t new_size, size_t old_size);
5213
5214#ifdef ruby_sized_xrealloc
5215#undef ruby_sized_xrealloc
5216#endif
5217void *
5218ruby_sized_xrealloc(void *ptr, size_t new_size, size_t old_size)
5219{
5220 return handle_malloc_failure(ruby_sized_xrealloc_body(ptr, new_size, old_size));
5221}
5222
5223static void *
5224ruby_sized_xrealloc_body(void *ptr, size_t new_size, size_t old_size)
5225{
5226 if ((ssize_t)new_size < 0) {
5227 negative_size_allocation_error("too large allocation size");
5228 }
5229
5230 return rb_gc_impl_realloc(rb_gc_get_objspace(), ptr, new_size, old_size, malloc_gc_allowed());
5231}
5232
5233void *
5234ruby_xrealloc(void *ptr, size_t new_size)
5235{
5236 return ruby_sized_xrealloc(ptr, new_size, 0);
5237}
5238
5239static void *ruby_sized_xrealloc2_body(void *ptr, size_t n, size_t size, size_t old_n);
5240
5241#ifdef ruby_sized_xrealloc2
5242#undef ruby_sized_xrealloc2
5243#endif
5244void *
5245ruby_sized_xrealloc2(void *ptr, size_t n, size_t size, size_t old_n)
5246{
5247 return handle_malloc_failure(ruby_sized_xrealloc2_body(ptr, n, size, old_n));
5248}
5249
5250static void *
5251ruby_sized_xrealloc2_body(void *ptr, size_t n, size_t size, size_t old_n)
5252{
5253 size_t len = xmalloc2_size(n, size);
5254 return rb_gc_impl_realloc(rb_gc_get_objspace(), ptr, len, old_n * size, malloc_gc_allowed());
5255}
5256
5257void *
5258ruby_xrealloc2(void *ptr, size_t n, size_t size)
5259{
5260 return ruby_sized_xrealloc2(ptr, n, size, 0);
5261}
5262
5263#ifdef ruby_sized_xfree
5264#undef ruby_sized_xfree
5265#endif
5266void
5267ruby_sized_xfree(void *x, size_t size)
5268{
5269 if (LIKELY(x)) {
5270 /* It's possible for a C extension's pthread destructor function set by pthread_key_create
5271 * to be called after ruby_vm_destruct and attempt to free memory. Fall back to mimfree in
5272 * that case. */
5273 if (LIKELY(GET_VM())) {
5274 rb_gc_impl_free(rb_gc_get_objspace(), x, size);
5275 }
5276 else {
5277 ruby_mimfree(x);
5278 }
5279 }
5280}
5281
5282void
5283ruby_xfree(void *x)
5284{
5285 ruby_sized_xfree(x, 0);
5286}
5287
5288void *
5289rb_xmalloc_mul_add(size_t x, size_t y, size_t z) /* x * y + z */
5290{
5291 size_t w = size_mul_add_or_raise(x, y, z, rb_eArgError);
5292 return ruby_xmalloc(w);
5293}
5294
5295void *
5296rb_xcalloc_mul_add(size_t x, size_t y, size_t z) /* x * y + z */
5297{
5298 size_t w = size_mul_add_or_raise(x, y, z, rb_eArgError);
5299 return ruby_xcalloc(w, 1);
5300}
5301
5302void *
5303rb_xrealloc_mul_add(const void *p, size_t x, size_t y, size_t z) /* x * y + z */
5304{
5305 size_t w = size_mul_add_or_raise(x, y, z, rb_eArgError);
5306 return ruby_xrealloc((void *)p, w);
5307}
5308
5309void *
5310rb_xmalloc_mul_add_mul(size_t x, size_t y, size_t z, size_t w) /* x * y + z * w */
5311{
5312 size_t u = size_mul_add_mul_or_raise(x, y, z, w, rb_eArgError);
5313 return ruby_xmalloc(u);
5314}
5315
5316void *
5317rb_xcalloc_mul_add_mul(size_t x, size_t y, size_t z, size_t w) /* x * y + z * w */
5318{
5319 size_t u = size_mul_add_mul_or_raise(x, y, z, w, rb_eArgError);
5320 return ruby_xcalloc(u, 1);
5321}
5322
5323/* Mimic ruby_xmalloc, but need not rb_objspace.
5324 * should return pointer suitable for ruby_xfree
5325 */
5326void *
5327ruby_mimmalloc(size_t size)
5328{
5329 void *mem;
5330#if CALC_EXACT_MALLOC_SIZE
5331 size += sizeof(struct malloc_obj_info);
5332#endif
5333 mem = malloc(size);
5334#if CALC_EXACT_MALLOC_SIZE
5335 if (!mem) {
5336 return NULL;
5337 }
5338 else
5339 /* set 0 for consistency of allocated_size/allocations */
5340 {
5341 struct malloc_obj_info *info = mem;
5342 info->size = 0;
5343 mem = info + 1;
5344 }
5345#endif
5346 return mem;
5347}
5348
5349void *
5350ruby_mimcalloc(size_t num, size_t size)
5351{
5352 void *mem;
5353#if CALC_EXACT_MALLOC_SIZE
5354 struct rbimpl_size_overflow_tag t = rbimpl_size_mul_overflow(num, size);
5355 if (UNLIKELY(t.overflowed)) {
5356 return NULL;
5357 }
5358 size = t.result + sizeof(struct malloc_obj_info);
5359 mem = calloc1(size);
5360 if (!mem) {
5361 return NULL;
5362 }
5363 else
5364 /* set 0 for consistency of allocated_size/allocations */
5365 {
5366 struct malloc_obj_info *info = mem;
5367 info->size = 0;
5368 mem = info + 1;
5369 }
5370#else
5371 mem = calloc(num, size);
5372#endif
5373 return mem;
5374}
5375
5376void
5377ruby_mimfree(void *ptr)
5378{
5379#if CALC_EXACT_MALLOC_SIZE
5380 struct malloc_obj_info *info = (struct malloc_obj_info *)ptr - 1;
5381 ptr = info;
5382#endif
5383 free(ptr);
5384}
5385
5386void
5387rb_gc_adjust_memory_usage(ssize_t diff)
5388{
5389 unless_objspace(objspace) { return; }
5390
5391 rb_gc_impl_adjust_memory_usage(objspace, diff);
5392}
5393
5394const char *
5395rb_obj_info(VALUE obj)
5396{
5397 return obj_info(obj);
5398}
5399
5400void
5401rb_obj_info_dump(VALUE obj)
5402{
5403 char buff[0x100];
5404 fprintf(stderr, "rb_obj_info_dump: %s\n", rb_raw_obj_info(buff, 0x100, obj));
5405}
5406
5407void
5408rb_obj_info_dump_loc(VALUE obj, const char *file, int line, const char *func)
5409{
5410 char buff[0x100];
5411 fprintf(stderr, "<OBJ_INFO:%s@%s:%d> %s\n", func, file, line, rb_raw_obj_info(buff, 0x100, obj));
5412}
5413
5414void
5415rb_gc_before_fork(void)
5416{
5417 rb_gc_impl_before_fork(rb_gc_get_objspace());
5418}
5419
5420void
5421rb_gc_after_fork(rb_pid_t pid)
5422{
5423 rb_gc_impl_after_fork(rb_gc_get_objspace(), pid);
5424}
5425
5426bool
5427rb_gc_obj_shareable_p(VALUE obj)
5428{
5429 return RB_OBJ_SHAREABLE_P(obj);
5430}
5431
5432void
5433rb_gc_rp(VALUE obj)
5434{
5435 rp(obj);
5436}
5437
5439 VALUE parent;
5440 long err_count;
5441};
5442
5443static void
5444check_shareable_i(const VALUE child, void *ptr)
5445{
5446 struct check_shareable_data *data = (struct check_shareable_data *)ptr;
5447
5448 if (!rb_gc_obj_shareable_p(child)) {
5449 fprintf(stderr, "(a) ");
5450 rb_gc_rp(data->parent);
5451 fprintf(stderr, "(b) ");
5452 rb_gc_rp(child);
5453 fprintf(stderr, "check_shareable_i: shareable (a) -> unshareable (b)\n");
5454
5455 data->err_count++;
5456 rb_bug("!! violate shareable constraint !!");
5457 }
5458}
5459
5460static bool gc_checking_shareable = false;
5461
5462static void
5463gc_verify_shareable(void *objspace, VALUE obj, void *data)
5464{
5465 // while gc_checking_shareable is true,
5466 // other Ractors should not run the GC, until the flag is not local.
5467 // TODO: remove VM locking if the flag is Ractor local
5468
5469 unsigned int lev = RB_GC_VM_LOCK();
5470 {
5471 gc_checking_shareable = true;
5472 rb_objspace_reachable_objects_from(obj, check_shareable_i, (void *)data);
5473 gc_checking_shareable = false;
5474 }
5475 RB_GC_VM_UNLOCK(lev);
5476}
5477
5478// TODO: only one level (non-recursive)
5479void
5480rb_gc_verify_shareable(VALUE obj)
5481{
5482 rb_objspace_t *objspace = rb_gc_get_objspace();
5483 struct check_shareable_data data = {
5484 .parent = obj,
5485 .err_count = 0,
5486 };
5487 gc_verify_shareable(objspace, obj, &data);
5488
5489 if (data.err_count > 0) {
5490 rb_bug("rb_gc_verify_shareable");
5491 }
5492}
5493
5494bool
5495rb_gc_checking_shareable(void)
5496{
5497 return gc_checking_shareable;
5498}
5499
5500/*
5501 * Document-module: ObjectSpace
5502 *
5503 * The ObjectSpace module contains a number of routines
5504 * that interact with the garbage collection facility and allow you to
5505 * traverse all living objects with an iterator.
5506 *
5507 * ObjectSpace also provides support for object finalizers, procs that will be
5508 * called after a specific object was destroyed by garbage collection. See
5509 * the documentation for +ObjectSpace.define_finalizer+ for important
5510 * information on how to use this method correctly.
5511 *
5512 * a = "A"
5513 * b = "B"
5514 *
5515 * ObjectSpace.define_finalizer(a, proc {|id| puts "Finalizer one on #{id}" })
5516 * ObjectSpace.define_finalizer(b, proc {|id| puts "Finalizer two on #{id}" })
5517 *
5518 * a = nil
5519 * b = nil
5520 *
5521 * _produces:_
5522 *
5523 * Finalizer two on 537763470
5524 * Finalizer one on 537763480
5525 */
5526
5527/* Document-class: GC::Profiler
5528 *
5529 * The GC profiler provides access to information on GC runs including time,
5530 * length and object space size.
5531 *
5532 * Example:
5533 *
5534 * GC::Profiler.enable
5535 *
5536 * require 'rdoc/rdoc'
5537 *
5538 * GC::Profiler.report
5539 *
5540 * GC::Profiler.disable
5541 *
5542 * See also GC.count, GC.malloc_allocated_size and GC.malloc_allocations
5543 */
5544
5545#include "gc.rbinc"
5546
5547void
5548Init_GC(void)
5549{
5550#undef rb_intern
5551 rb_gc_register_address(&id2ref_value);
5552
5553 malloc_offset = gc_compute_malloc_offset();
5554
5555 rb_mGC = rb_define_module("GC");
5556
5557 VALUE rb_mObjSpace = rb_define_module("ObjectSpace");
5558
5559 rb_define_module_function(rb_mObjSpace, "each_object", os_each_obj, -1);
5560
5561 rb_define_module_function(rb_mObjSpace, "define_finalizer", define_final, -1);
5562 rb_define_module_function(rb_mObjSpace, "undefine_finalizer", undefine_final, 1);
5563
5564 rb_define_module_function(rb_mObjSpace, "_id2ref", os_id2ref, 1);
5565
5566 rb_vm_register_special_exception(ruby_error_nomemory, rb_eNoMemError, "failed to allocate memory");
5567
5568 rb_define_method(rb_cBasicObject, "__id__", rb_obj_id, 0);
5569 rb_define_method(rb_mKernel, "object_id", rb_obj_id, 0);
5570
5571 rb_define_module_function(rb_mObjSpace, "count_objects", count_objects, -1);
5572
5573 rb_gc_impl_init();
5574}
5575
5576// Set a name for the anonymous virtual memory area. `addr` is the starting
5577// address of the area and `size` is its length in bytes. `name` is a
5578// NUL-terminated human-readable string.
5579//
5580// This function is usually called after calling `mmap()`. The human-readable
5581// annotation helps developers identify the call site of `mmap()` that created
5582// the memory mapping.
5583//
5584// This function currently only works on Linux 5.17 or higher. After calling
5585// this function, we can see annotations in the form of "[anon:...]" in
5586// `/proc/self/maps`, where `...` is the content of `name`. This function has
5587// no effect when called on other platforms.
5588void
5589ruby_annotate_mmap(const void *addr, unsigned long size, const char *name)
5590{
5591#if defined(HAVE_SYS_PRCTL_H) && defined(PR_SET_VMA) && defined(PR_SET_VMA_ANON_NAME)
5592 // The name length cannot exceed 80 (including the '\0').
5593 RUBY_ASSERT(strlen(name) < 80);
5594 prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, (unsigned long)addr, size, name);
5595 // We ignore errors in prctl. prctl may set errno to EINVAL for several
5596 // reasons.
5597 // 1. The attr (PR_SET_VMA_ANON_NAME) is not a valid attribute.
5598 // 2. addr is an invalid address.
5599 // 3. The string pointed by name is too long.
5600 // The first error indicates PR_SET_VMA_ANON_NAME is not available, and may
5601 // happen if we run the compiled binary on an old kernel. In theory, all
5602 // other errors should result in a failure. But since EINVAL cannot tell
5603 // the first error from others, and this function is mainly used for
5604 // debugging, we silently ignore the error.
5605 errno = 0;
5606#endif
5607}
#define RUBY_ASSERT_ALWAYS(expr,...)
A variant of RUBY_ASSERT that does not interface with RUBY_DEBUG.
Definition assert.h:199
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
#define RUBY_ATOMIC_VALUE_CAS(var, oldval, newval)
Identical to RUBY_ATOMIC_CAS, except it expects its arguments are VALUE.
Definition atomic.h:406
#define RUBY_ATOMIC_SIZE_FETCH_ADD(var, val)
Identical to RUBY_ATOMIC_FETCH_ADD, except it expects its arguments to be size_t.
Definition atomic.h:235
#define RUBY_ATOMIC_CAS(var, oldval, newval)
Atomic compare-and-swap.
Definition atomic.h:165
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 rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_module_function(klass, mid, func, arity)
Defines klass#mid and makes it a module function.
uint32_t rb_event_flag_t
Represents event(s).
Definition event.h:108
#define RUBY_INTERNAL_EVENT_NEWOBJ
Object allocated.
Definition event.h:93
@ RUBY_FL_WB_PROTECTED
Definition fl_type.h:198
VALUE rb_define_module(const char *name)
Defines a top-level module.
Definition class.c:1601
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:3158
#define T_COMPLEX
Old name of RUBY_T_COMPLEX.
Definition value_type.h:59
#define TYPE(_)
Old name of rb_type.
Definition value_type.h:108
#define FL_SINGLETON
Old name of RUBY_FL_SINGLETON.
Definition fl_type.h:58
#define T_FILE
Old name of RUBY_T_FILE.
Definition value_type.h:62
#define FL_UNSET_RAW
Old name of RB_FL_UNSET_RAW.
Definition fl_type.h:133
#define ALLOC
Old name of RB_ALLOC.
Definition memory.h:400
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define xfree
Old name of ruby_xfree.
Definition xmalloc.h:58
#define T_MASK
Old name of RUBY_T_MASK.
Definition value_type.h:68
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
#define T_NIL
Old name of RUBY_T_NIL.
Definition value_type.h:72
#define UNREACHABLE
Old name of RBIMPL_UNREACHABLE.
Definition assume.h:28
#define T_FLOAT
Old name of RUBY_T_FLOAT.
Definition value_type.h:64
#define T_IMEMO
Old name of RUBY_T_IMEMO.
Definition value_type.h:67
#define ID2SYM
Old name of RB_ID2SYM.
Definition symbol.h:44
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
Definition value_type.h:57
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
Definition value_type.h:79
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
Definition fl_type.h:134
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
Definition value_type.h:63
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
Definition assume.h:29
#define SYM2ID
Old name of RB_SYM2ID.
Definition symbol.h:45
#define T_DATA
Old name of RUBY_T_DATA.
Definition value_type.h:60
#define FIXNUM_FLAG
Old name of RUBY_FIXNUM_FLAG.
#define LL2NUM
Old name of RB_LL2NUM.
Definition long_long.h:30
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:205
#define T_NONE
Old name of RUBY_T_NONE.
Definition value_type.h:74
#define T_NODE
Old name of RUBY_T_NODE.
Definition value_type.h:73
#define SIZET2NUM
Old name of RB_SIZE2NUM.
Definition size_t.h:62
#define FL_FINALIZE
Old name of RUBY_FL_FINALIZE.
Definition fl_type.h:61
#define T_MODULE
Old name of RUBY_T_MODULE.
Definition value_type.h:70
#define ASSUME
Old name of RBIMPL_ASSUME.
Definition assume.h:27
#define T_TRUE
Old name of RUBY_T_TRUE.
Definition value_type.h:81
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
Definition value_type.h:76
#define T_ICLASS
Old name of RUBY_T_ICLASS.
Definition value_type.h:66
#define T_HASH
Old name of RUBY_T_HASH.
Definition value_type.h:65
#define FL_ABLE
Old name of RB_FL_ABLE.
Definition fl_type.h:121
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
Definition fl_type.h:131
#define rb_ary_new3
Old name of rb_ary_new_from_args.
Definition array.h:658
#define LONG2NUM
Old name of RB_LONG2NUM.
Definition long.h:50
#define T_FALSE
Old name of RUBY_T_FALSE.
Definition value_type.h:61
#define ULL2NUM
Old name of RB_ULL2NUM.
Definition long_long.h:31
#define T_UNDEF
Old name of RUBY_T_UNDEF.
Definition value_type.h:82
#define FLONUM_P
Old name of RB_FLONUM_P.
#define Qtrue
Old name of RUBY_Qtrue.
#define T_ZOMBIE
Old name of RUBY_T_ZOMBIE.
Definition value_type.h:83
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
Definition long.h:46
#define T_ARRAY
Old name of RUBY_T_ARRAY.
Definition value_type.h:56
#define T_OBJECT
Old name of RUBY_T_OBJECT.
Definition value_type.h:75
#define NIL_P
Old name of RB_NIL_P.
#define NUM2ULL
Old name of RB_NUM2ULL.
Definition long_long.h:35
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
Definition fl_type.h:59
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
Definition value_type.h:80
#define T_MATCH
Old name of RUBY_T_MATCH.
Definition value_type.h:69
#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 T_MOVED
Old name of RUBY_T_MOVED.
Definition value_type.h:71
#define xcalloc
Old name of ruby_xcalloc.
Definition xmalloc.h:55
#define FL_UNSET
Old name of RB_FL_UNSET.
Definition fl_type.h:132
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define NUM2SIZET
Old name of RB_NUM2SIZE.
Definition size_t.h:61
#define SYMBOL_P
Old name of RB_SYMBOL_P.
Definition value_type.h:88
#define T_REGEXP
Old name of RUBY_T_REGEXP.
Definition value_type.h:77
size_t ruby_stack_length(VALUE **p)
Queries what Ruby thinks is the machine stack.
Definition gc.c:2550
int ruby_stack_check(void)
Checks for stack overflow.
Definition gc.c:2590
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
VALUE rb_eNoMemError
NoMemoryError exception.
Definition error.c:1442
VALUE rb_eRangeError
RangeError exception.
Definition error.c:1435
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
Definition error.h:475
VALUE rb_eTypeError
TypeError exception.
Definition error.c:1431
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
Definition error.c:466
@ RB_WARN_CATEGORY_DEPRECATED
Warning is for deprecated features.
Definition error.h:48
VALUE rb_mKernel
Kernel module.
Definition object.c:60
VALUE rb_mGC
GC module.
Definition gc.c:424
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
Definition object.c:264
VALUE rb_cBasicObject
BasicObject class.
Definition object.c:59
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
Definition object.c:923
size_t rb_obj_embedded_size(uint32_t fields_count)
Internal header for Object.
Definition object.c:94
VALUE rb_to_int(VALUE val)
Identical to rb_check_to_int(), except it raises in case of conversion mismatch.
Definition object.c:3306
#define RB_POSFIXABLE(_)
Checks if the passed value is in range of fixnum, assuming it is a positive number.
Definition fixnum.h:43
int rb_enc_str_coderange(VALUE str)
Scans the passed string to collect its code range.
Definition string.c:964
VALUE rb_funcall(VALUE recv, ID mid, int n,...)
Calls a method.
Definition vm_eval.c:1119
void rb_ary_free(VALUE ary)
Destroys the given array for no reason.
#define RETURN_ENUMERATOR(obj, argc, argv)
Identical to RETURN_SIZED_ENUMERATOR(), except its size is unknown.
Definition enumerator.h:242
VALUE rb_block_proc(void)
Constructs a Proc object from implicitly passed components.
Definition proc.c:994
VALUE rb_obj_is_proc(VALUE recv)
Queries if the given object is a proc.
Definition proc.c:126
void rb_str_free(VALUE str)
Destroys the given string for no reason.
Definition string.c:1769
size_t rb_str_capacity(VALUE str)
Queries the capacity of the given string.
Definition string.c:1018
VALUE rb_class_path_cached(VALUE mod)
Just another name of rb_mod_name.
Definition variable.c:389
void rb_free_generic_ivar(VALUE obj)
Frees the list of instance variables.
Definition variable.c:1308
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
Definition vm_method.c:1719
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
Definition vm_eval.c:688
rb_alloc_func_t rb_get_alloc_func(VALUE klass)
Queries the allocator function of a class.
Definition vm_method.c:1725
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:3464
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
Definition symbol.c:994
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
Definition io.h:2
int rb_io_fptr_finalize(rb_io_t *fptr)
Destroys the given IO.
Definition io.c:5767
int len
Length of the buffer.
Definition io.h:8
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
Definition ractor.h:235
void * rb_thread_call_with_gvl(void *(*func)(void *), void *data1)
(Re-)acquires the GVL.
Definition thread.c:2063
VALUE rb_yield(VALUE val)
Yields the block.
Definition vm_eval.c:1374
#define RBIMPL_ATTR_MAYBE_UNUSED()
Wraps (or simulates) [[maybe_unused]].
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
Definition memory.h:167
VALUE type(ANYARGS)
ANYARGS-ed function type.
#define RARRAY_LEN
Just another name of rb_array_len.
Definition rarray.h:51
#define RARRAY(obj)
Convenient casting macro.
Definition rarray.h:44
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
Definition rarray.h:52
#define RBASIC(obj)
Convenient casting macro.
Definition rbasic.h:40
#define RCLASS(obj)
Convenient casting macro.
Definition rclass.h:38
#define DATA_PTR(obj)
Convenient getter macro.
Definition rdata.h:67
#define RDATA(obj)
Convenient casting macro.
Definition rdata.h:59
void(*) RUBY_DATA_FUNC(void *)
This is the type of callbacks registered to RData.
Definition rdata.h:104
#define RUBY_DEFAULT_FREE
This is a value you can set to RData::dfree.
Definition rdata.h:78
#define RFILE(obj)
Convenient casting macro.
Definition rfile.h:50
#define RHASH_SIZE(h)
Queries the size of the hash.
Definition rhash.h:69
#define RHASH_EMPTY_P(h)
Checks if the hash is empty.
Definition rhash.h:79
#define RMATCH(obj)
Convenient casting macro.
Definition rmatch.h:37
#define ROBJECT(obj)
Convenient casting macro.
Definition robject.h:43
#define RREGEXP(obj)
Convenient casting macro.
Definition rregexp.h:37
#define RREGEXP_PTR(obj)
Convenient accessor macro.
Definition rregexp.h:45
#define RSTRING(obj)
Convenient casting macro.
Definition rstring.h:41
#define TypedData_Wrap_Struct(klass, data_type, sval)
Converts sval, a pointer to your struct, into a Ruby object.
Definition rtypeddata.h:461
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
Definition rtypeddata.h:205
#define RTYPEDDATA(obj)
Convenient casting macro.
Definition rtypeddata.h:95
const char * rb_obj_classname(VALUE obj)
Queries the name of the class of the passed object.
Definition variable.c:515
void rb_p(VALUE obj)
Inspects an object.
Definition io.c:9133
#define errno
Ractor-aware version of errno.
Definition ruby.h:388
int ruby_native_thread_p(void)
Queries if the thread which calls this function is a ruby's thread.
Definition thread.c:5839
#define RTEST
This is an old name of RB_TEST.
Defines old _.
#define _(args)
This was a transition path from K&R to ANSI.
Definition stdarg.h:35
Ruby's array.
Definition rarray.h:128
Ruby object's base components.
Definition rbasic.h:69
Definition rdata.h:120
RUBY_DATA_FUNC dfree
This function is called when the object is no longer used.
Definition rdata.h:143
RUBY_DATA_FUNC dmark
This function is called when the object is experiencing GC marks.
Definition rdata.h:134
void * data
Pointer to the actual C level struct that you want to wrap.
Definition rdata.h:149
Definition hash.h:53
Ruby's ordinal objects.
Definition robject.h:85
Ruby's String.
Definition rstring.h:196
"Typed" user data.
Definition rtypeddata.h:358
void * data
Pointer to the actual C level struct that you want to wrap.
Definition rtypeddata.h:378
VALUE fields_obj
Direct reference to the slots that holds instance variables, if any.
Definition rtypeddata.h:364
Definition gc_impl.h:15
Ruby's IO, metadata and buffers.
Definition io.h:295
struct rmatch_offset * char_offset
Capture group offsets, in C array.
Definition rmatch.h:79
int char_offset_num_allocated
Number of rmatch_offset that rmatch::char_offset holds.
Definition rmatch.h:82
struct re_registers regs
"Registers" of a match.
Definition rmatch.h:76
Represents the region of a capture group.
Definition rmatch.h:65
void rb_native_mutex_lock(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_lock.
void rb_native_mutex_initialize(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_initialize.
void rb_native_mutex_unlock(rb_nativethread_lock_t *lock)
Just another name of rb_nativethread_lock_unlock.
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
Definition value.h:63
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
ruby_value_type
C-level type of an object.
Definition value_type.h:113