14#include "ruby/internal/config.h"
19#if defined(__wasm__) && !defined(__EMSCRIPTEN__)
20# include "wasm/setjmp.h"
21# include "wasm/machine.h"
29#ifndef HAVE_MALLOC_USABLE_SIZE
31# define HAVE_MALLOC_USABLE_SIZE
32# define malloc_usable_size(a) mi_usable_size(a)
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)
42#ifdef HAVE_MALLOC_USABLE_SIZE
43# ifdef RUBY_ALTERNATIVE_MALLOC_HEADER
45# elif defined(USE_MIMALLOC)
47# pragma push_macro("restrict")
50# pragma pop_macro("restrict")
51# elif defined(HAVE_MALLOC_H)
53# elif defined(HAVE_MALLOC_NP_H)
54# include <malloc_np.h>
55# elif defined(HAVE_MALLOC_MALLOC_H)
56# include <malloc/malloc.h>
66#ifdef HAVE_SYS_RESOURCE_H
67# include <sys/resource.h>
70#if defined _WIN32 || defined __CYGWIN__
72#elif defined(HAVE_POSIX_MEMALIGN)
73#elif defined(HAVE_MEMALIGN)
80#include <emscripten.h>
84#ifdef HAVE_SYS_PRCTL_H
91#include "debug_counter.h"
92#include "eval_intern.h"
96#include "internal/class.h"
97#include "internal/compile.h"
98#include "internal/complex.h"
99#include "internal/concurrent_set.h"
100#include "internal/cont.h"
101#include "internal/error.h"
102#include "internal/eval.h"
103#include "internal/gc.h"
104#include "internal/hash.h"
105#include "internal/imemo.h"
106#include "internal/io.h"
107#include "internal/numeric.h"
108#include "internal/object.h"
109#include "internal/proc.h"
110#include "internal/rational.h"
111#include "internal/re.h"
112#include "internal/sanitizers.h"
113#include "internal/struct.h"
114#include "internal/symbol.h"
115#include "internal/thread.h"
116#include "internal/variable.h"
117#include "internal/warnings.h"
127#include "ruby_assert.h"
128#include "ruby_atomic.h"
133#include "vm_callinfo.h"
134#include "ractor_core.h"
135#include "internal/ractor.h"
145rb_gc_print_backtrace(
void)
147 rb_print_backtrace(stderr);
151rb_gc_vm_lock(
const char *file,
int line)
153 unsigned int lev = 0;
154 rb_vm_lock_enter(&lev, file, line);
159rb_gc_vm_unlock(
unsigned int lev,
const char *file,
int line)
161 rb_vm_lock_leave(&lev, file, line);
165rb_gc_vm_lock_no_barrier(
const char *file,
int line)
167 unsigned int lev = 0;
168 rb_vm_lock_enter_nb(&lev, file, line);
173rb_gc_vm_unlock_no_barrier(
unsigned int lev,
const char *file,
int line)
175 rb_vm_lock_leave_nb(&lev, file, line);
179rb_gc_vm_barrier(
void)
185rb_gc_get_ractor_newobj_cache(
void)
187 return GET_RACTOR()->newobj_cache;
193 context->ec = GET_EC();
199 return ruby_vm_event_flags & event;
205 if (LIKELY(!rb_gc_event_hook_required_p(event)))
return;
213 rb_execution_context_t *ec = GET_EC();
216 bool gc_thread_p =
false;
224# ifdef RB_THREAD_LOCAL_SPECIFIER
225 rb_current_ec_set(ec);
227 native_tls_set(ruby_current_ec_key, ec);
232 if (RB_LIKELY(ec->cfp != NULL)) {
233 EXEC_EVENT_HOOK(ec, event, ec->cfp->self, 0, 0, 0, obj);
238# ifdef RB_THREAD_LOCAL_SPECIFIER
239 rb_current_ec_set(NULL);
241 native_tls_set(ruby_current_ec_key, NULL);
259rb_gc_stash_cleanup_objspace(
void)
261 GET_VM()->gc.cleanup_objspace = rb_gc_get_objspace();
268NOINLINE(
static void *gc_current_objspace_slow(rb_ractor_t *
const cr));
271gc_current_objspace_slow(rb_ractor_t *
const cr)
275 if (RB_UNLIKELY(ruby_vm_during_cleanup) && GET_VM()->gc.cleanup_objspace) {
276 return GET_VM()->gc.cleanup_objspace;
281 return GET_VM()->ractor.main_ractor->objspace;
289gc_current_objspace_of(rb_ractor_t *
const cr)
291 if (RB_LIKELY(cr != NULL && gc_objspace_override_count == 0)) {
295 return gc_current_objspace_slow(cr);
299rb_gc_get_objspace(
void)
301 return gc_current_objspace_of(rb_current_ractor_raw(
false));
310 rb_control_frame_t *cfp;
315 rb_execution_context_t *
volatile ec = GET_EC();
316#define RESTORE_FINALIZER() (\
317 ec->cfp = saved.cfp, \
318 ec->cfp->sp = saved.sp, \
319 ec->errinfo = saved.errinfo)
321 saved.errinfo = ec->errinfo;
323 saved.sp = ec->cfp->sp;
327 ASSERT_vm_unlocking();
328 rb_ractor_ignore_belonging(
true);
330 enum ruby_tag_type state = EC_EXEC_TAG();
331 if (state != TAG_NONE) {
334 VALUE failed_final = saved.final;
337 rb_warn(
"Exception in finalizer %+"PRIsVALUE, failed_final);
338 rb_ec_error_print(ec, ec->errinfo);
342 for (
rb_len_t i = saved.finished; RESTORE_FINALIZER(), i < count; saved.finished = ++i) {
343 saved.final = callback(i, data);
347 rb_ractor_ignore_belonging(
false);
348#undef RESTORE_FINALIZER
352rb_gc_set_pending_interrupt(
void)
354 rb_execution_context_t *ec = GET_EC();
355 ec->interrupt_mask |= PENDING_INTERRUPT_MASK;
365 rb_ractor_t *
const cr = rb_current_ractor_raw(
false);
366 if (cr == NULL || cr->objspace !=
objspace) {
370 rb_vm_t *vm = GET_VM();
372 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
374 rb_postponed_job_trigger_for_ractor(pjob, r->pub.self);
385 rb_postponed_job_trigger_for_ractor(pjob, GET_VM()->ractor.main_ractor->pub.self);
389rb_gc_unset_pending_interrupt(
void)
391 rb_execution_context_t *ec = GET_EC();
392 ec->interrupt_mask &= ~PENDING_INTERRUPT_MASK;
396rb_gc_multi_ractor_p(
void)
398 return rb_multi_ractor_p();
402rb_gc_shutdown_call_finalizer_p(
VALUE obj)
408 if (!rbimpl_typeddata_embedded_p(obj) && !
RTYPEDDATA(obj)->data)
return false;
410 if (rb_obj_is_thread(obj))
return false;
411 if (rb_obj_is_mutex(obj))
return false;
412 if (rb_obj_is_fiber(obj))
return false;
413 if (rb_ractor_p(obj))
return false;
414 if (rb_obj_is_fstring_table(obj))
return false;
415 if (rb_obj_is_symbol_table(obj))
return false;
434rb_gc_obj_changed_slot_size(
VALUE obj,
size_t slot_size)
436 shape_id_t shape_id = rb_obj_shape_transition_capacity(obj, rb_shape_capacity_for_slot_size(slot_size));
437 RBASIC_SET_FULL_SHAPE_ID(obj, shape_id);
440void rb_vm_update_references(
void *ptr);
442#define rb_setjmp(env) RUBY_SETJMP(env)
443#define rb_jmp_buf rb_jmpbuf_t
445#if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
446#define MAP_ANONYMOUS MAP_ANON
449#define unless_objspace(objspace) \
451 rb_vm_t *unless_objspace_vm = GET_VM(); \
452 if (unless_objspace_vm) objspace = rb_gc_get_objspace(); \
455#define RMOVED(obj) ((struct RMoved *)(obj))
457#define TYPED_UPDATE_IF_MOVED(_objspace, _type, _thing) do { \
458 if (gc_object_moved_p_internal((_objspace), (VALUE)(_thing))) { \
459 *(_type *)&(_thing) = (_type)gc_location_internal(_objspace, (VALUE)_thing); \
463#define UPDATE_IF_MOVED(_objspace, _thing) TYPED_UPDATE_IF_MOVED(_objspace, VALUE, _thing)
465#if RUBY_MARK_FREE_DEBUG
466int ruby_gc_debug_indent = 0;
469#ifndef RGENGC_OBJ_INFO
470# define RGENGC_OBJ_INFO RGENGC_CHECK_MODE
473#ifndef CALC_EXACT_MALLOC_SIZE
474# define CALC_EXACT_MALLOC_SIZE 0
479static size_t malloc_offset = 0;
482#if defined(HAVE_MALLOC_USABLE_SIZE) && !defined(USE_MIMALLOC)
484gc_compute_malloc_offset(
void)
495 for (offset = 0; offset <= 16; offset += 8) {
496 size_t allocated = (64 - offset);
497 void *test_ptr = malloc(allocated);
498 size_t wasted = malloc_usable_size(test_ptr) - allocated;
509gc_compute_malloc_offset(
void)
517rb_malloc_grow_capa(
size_t current,
size_t type_size)
519 size_t current_capacity = current;
520 if (current_capacity < 4) {
521 current_capacity = 4;
523 current_capacity *= type_size;
526 size_t new_capacity = (current_capacity * 2);
529 if (rb_popcount64(new_capacity) != 1) {
530 new_capacity = (size_t)(1 << (64 - nlz_int64(new_capacity)));
533 new_capacity -= malloc_offset;
534 new_capacity /= type_size;
535 if (current > new_capacity) {
536 rb_bug(
"rb_malloc_grow_capa: current_capacity=%zu, new_capacity=%zu, malloc_offset=%zu", current, new_capacity, malloc_offset);
542static inline struct rbimpl_size_overflow_tag
543size_mul_add_overflow(size_t x, size_t y, size_t z)
545 struct rbimpl_size_overflow_tag t = rbimpl_size_mul_overflow(x, y);
546 struct rbimpl_size_overflow_tag u = rbimpl_size_add_overflow(t.result, z);
547 return (
struct rbimpl_size_overflow_tag) { t.overflowed || u.overflowed, u.result };
550static inline struct rbimpl_size_overflow_tag
551size_mul_add_mul_overflow(size_t x, size_t y, size_t z, size_t w)
553 struct rbimpl_size_overflow_tag t = rbimpl_size_mul_overflow(x, y);
554 struct rbimpl_size_overflow_tag u = rbimpl_size_mul_overflow(z, w);
555 struct rbimpl_size_overflow_tag v = rbimpl_size_add_overflow(t.result, u.result);
556 return (
struct rbimpl_size_overflow_tag) { t.overflowed || u.overflowed || v.overflowed, v.result };
559PRINTF_ARGS(NORETURN(
static void gc_raise(
VALUE,
const char*, ...)), 2, 3);
562size_mul_or_raise(
size_t x,
size_t y,
VALUE exc)
564 struct rbimpl_size_overflow_tag t = rbimpl_size_mul_overflow(x, y);
565 if (LIKELY(!t.overflowed)) {
574 "integer overflow: %"PRIuSIZE
577 x, y, (
size_t)SIZE_MAX);
582rb_size_mul_or_raise(
size_t x,
size_t y,
VALUE exc)
584 return size_mul_or_raise(x, y, exc);
588size_mul_add_or_raise(
size_t x,
size_t y,
size_t z,
VALUE exc)
590 struct rbimpl_size_overflow_tag t = size_mul_add_overflow(x, y, z);
591 if (LIKELY(!t.overflowed)) {
600 "integer overflow: %"PRIuSIZE
604 x, y, z, (
size_t)SIZE_MAX);
609rb_size_mul_add_or_raise(
size_t x,
size_t y,
size_t z,
VALUE exc)
611 return size_mul_add_or_raise(x, y, z, exc);
615size_mul_add_mul_or_raise(
size_t x,
size_t y,
size_t z,
size_t w,
VALUE exc)
617 struct rbimpl_size_overflow_tag t = size_mul_add_mul_overflow(x, y, z, w);
618 if (LIKELY(!t.overflowed)) {
627 "integer overflow: %"PRIdSIZE
632 x, y, z, w, (
size_t)SIZE_MAX);
636#if defined(HAVE_RB_GC_GUARDED_PTR_VAL) && HAVE_RB_GC_GUARDED_PTR_VAL
638volatile VALUE rb_gc_guarded_val;
640rb_gc_guarded_ptr_val(
volatile VALUE *ptr,
VALUE val)
642 rb_gc_guarded_val = val;
648static const char *obj_type_name(
VALUE obj);
654rb_gc_atfork_global_locks(
void)
656 rb_vm_t *vm = GET_VM();
660#include "gc/default/default.c"
662#if USE_MODULAR_GC && !defined(HAVE_DLOPEN)
663# error "Modular GC requires dlopen"
667typedef struct gc_function_map {
669 void *(*objspace_alloc)(void);
670 void (*objspace_init)(
void *objspace_ptr);
671 void *(*ractor_cache_alloc)(
void *objspace_ptr,
void *ractor);
672 void (*objspace_retire_gc)(
void *objspace_ptr);
673 void (*set_params)(
void *objspace_ptr);
676 void (*shutdown_free_objects)(
void *objspace_ptr);
677 void (*objspace_free)(
void *objspace_ptr);
678 void (*ractor_cache_free)(
void *objspace_ptr,
void *cache);
680 void (*start)(
void *objspace_ptr,
bool full_mark,
bool immediate_mark,
bool immediate_sweep,
bool compact,
bool global);
681 bool (*during_gc_p)(
void *objspace_ptr);
682 void (*prepare_heap)(
void *objspace_ptr);
683 void (*gc_enable)(
void *objspace_ptr);
684 void (*gc_disable)(
void *objspace_ptr,
bool finish_current_gc);
685 bool (*gc_enabled_p)(
void *objspace_ptr);
686 bool (*user_gc_disabled_set)(
void *objspace_ptr,
bool disable);
687 bool (*user_gc_disabled_p)(
void *objspace_ptr);
688 bool (*multi_objspace_p)(void);
689 bool (*during_global_gc_p)(
void *objspace_ptr);
690 bool (*during_postmortem_p)(
void *objspace_ptr);
691 bool (*obj_foreign_p)(
void *objspace_ptr,
VALUE obj);
692 void (*objspace_set_ractor)(
void *objspace_ptr,
void *ractor);
693 void *(*obj_ractor)(
void *objspace_ptr,
VALUE obj);
694 bool (*shref_marked_p)(
void *objspace_ptr,
VALUE obj);
695 void (*objspace_zombify)(
void *objspace_ptr);
696 void (*objspace_absorb)(
void *dst_ptr,
void *src_ptr);
697 void (*gc_rest)(
void *objspace_ptr);
698 VALUE (*config_get)(
void *objpace_ptr);
699 void (*config_set)(
void *objspace_ptr,
VALUE hash);
700 void (*stress_set)(
void *objspace_ptr,
VALUE flag);
701 VALUE (*stress_get)(
void *objspace_ptr);
702 struct rb_gc_vm_context *(*get_vm_context)(
void *objspace_ptr);
704 VALUE (*new_obj)(
void *objspace_ptr,
void *cache_ptr,
VALUE klass,
VALUE flags,
bool wb_protected,
size_t alloc_size,
size_t *actual_alloc_size);
705 bool (*zjit_new_obj_fastpath)(
void *objspace_ptr,
size_t alloc_size,
VALUE flags,
VALUE klass,
struct rb_gc_zjit_fastpath *fastpath);
706 int32_t (*zjit_writebarrier_required_offset)(void);
707 size_t (*obj_slot_size)(
VALUE obj);
708 size_t (*size_slot_size)(
void *objspace_ptr,
size_t size);
709 bool (*size_allocatable_p)(
size_t size);
710 size_t (*max_allocation_size)(void);
712 void *(*malloc)(
void *objspace_ptr,
size_t size,
bool gc_allowed);
713 void *(*calloc)(
void *objspace_ptr,
size_t size,
bool gc_allowed);
714 void *(*realloc)(
void *objspace_ptr,
void *
ptr,
size_t new_size,
size_t old_size,
bool gc_allowed);
715 void (*free)(
void *objspace_ptr,
void *
ptr,
size_t old_size);
716 void (*adjust_memory_usage)(
void *objspace_ptr, ssize_t diff);
718 void (*mark)(
void *objspace_ptr,
VALUE obj);
719 void (*mark_and_move)(
void *objspace_ptr,
VALUE *
ptr);
720 void (*mark_and_pin)(
void *objspace_ptr,
VALUE obj);
721 void (*mark_maybe)(
void *objspace_ptr,
VALUE obj);
723 void (*declare_weak_references)(
void *objspace_ptr,
VALUE obj);
724 bool (*handle_weak_references_alive_p)(
void *objspace_ptr,
VALUE obj);
726 void (*register_pinning_obj)(
void *objspace_ptr,
VALUE obj);
727 bool (*object_moved_p)(
void *objspace_ptr,
VALUE obj);
728 bool (*pinned_p)(
void *objspace_ptr,
VALUE obj);
729 VALUE (*location)(
void *objspace_ptr,
VALUE value);
731 void (*writebarrier)(
void *objspace_ptr,
VALUE a,
VALUE b);
732 void (*writebarrier_unprotect)(
void *objspace_ptr,
VALUE obj);
733 void (*writebarrier_remember)(
void *objspace_ptr,
VALUE obj);
734 void (*obj_became_shareable)(
void *objspace_ptr,
VALUE obj);
736 void (*each_objects)(
void *objspace_ptr, int (*callback)(
void *,
void *, size_t,
void *),
void *data);
737 void (*each_objects_shareable)(
void *objspace_ptr, int (*callback)(
void *,
void *, size_t,
void *),
void *data);
738 void (*each_objects_foreign)(
void *objspace_ptr, int (*callback)(
void *,
void *, size_t,
void *),
void *data);
739 void (*each_object)(
void *objspace_ptr, void (*func)(
VALUE obj,
void *data),
void *data);
741 void (*make_zombie)(
void *objspace_ptr,
VALUE obj, void (*dfree)(
void *),
void *data);
743 void (*undefine_finalizer)(
void *objspace_ptr,
VALUE obj);
744 void (*copy_finalizer)(
void *objspace_ptr,
VALUE dest,
VALUE obj);
745 void (*shutdown_call_finalizer)(
void *objspace_ptr);
747 void (*before_fork)(
void *objspace_ptr);
748 void (*after_fork)(
void *objspace_ptr, rb_pid_t pid);
750 void (*set_measure_total_time)(
void *objspace_ptr,
VALUE flag);
751 bool (*get_measure_total_time)(
void *objspace_ptr);
752 unsigned long long (*get_total_time)(
void *objspace_ptr);
753 size_t (*gc_count)(
void *objspace_ptr);
754 VALUE (*latest_gc_info)(
void *objspace_ptr,
VALUE key);
755 VALUE (*stat)(
void *objspace_ptr,
VALUE hash_or_sym);
756 VALUE (*stat_heap)(
void *objspace_ptr,
VALUE heap_name,
VALUE hash_or_sym);
757 const char *(*active_gc_name)(void);
759 struct rb_gc_object_metadata_entry *(*object_metadata)(
void *objspace_ptr,
VALUE obj);
760 bool (*live_object_p)(
void *objspace_ptr,
const void *
ptr);
761 bool (*garbage_object_p)(
void *objspace_ptr,
VALUE obj);
762 void (*set_event_hook)(
void *objspace_ptr,
const rb_event_flag_t event);
763 void (*copy_attributes)(
void *objspace_ptr,
VALUE dest,
VALUE obj);
765 bool modular_gc_loaded_p;
766} rb_gc_function_map_t;
768static rb_gc_function_map_t rb_gc_functions;
770# define RUBY_GC_LIBRARY "RUBY_GC_LIBRARY"
771# define MODULAR_GC_DIR STRINGIZE(modular_gc_dir)
774ruby_modular_gc_init(
void)
779 const char *gc_so_file = getenv(RUBY_GC_LIBRARY);
781 rb_gc_function_map_t gc_functions = { 0 };
783 char *gc_so_path = NULL;
788 for (
size_t i = 0; i < strlen(gc_so_file); i++) {
789 char c = gc_so_file[i];
790 if (isalnum(c))
continue;
796 fprintf(stderr,
"Only alphanumeric, dash, and underscore is allowed in "RUBY_GC_LIBRARY
"\n");
801 size_t gc_so_path_size = strlen(MODULAR_GC_DIR
"librubygc." DLEXT) + strlen(gc_so_file) + 1;
804 size_t prefix_len = 0;
805 if (dladdr((
void *)(uintptr_t)ruby_modular_gc_init, &dli)) {
806 const char *base = strrchr(dli.dli_fname,
'/');
809# define end_with_p(lit) \
810 (prefix_len >= (tail = rb_strlen_lit(lit)) && \
811 memcmp(base - tail, lit, tail) == 0)
813 prefix_len = base - dli.dli_fname;
814 if (end_with_p(
"/bin") || end_with_p(
"/lib")) {
817 prefix_len += MODULAR_GC_DIR[0] !=
'/';
818 gc_so_path_size += prefix_len;
822 gc_so_path = alloca(gc_so_path_size);
824 size_t gc_so_path_idx = 0;
825#define GC_SO_PATH_APPEND(str) do { \
826 gc_so_path_idx += strlcpy(gc_so_path + gc_so_path_idx, str, gc_so_path_size - gc_so_path_idx); \
829 if (prefix_len > 0) {
830 memcpy(gc_so_path, dli.dli_fname, prefix_len);
831 gc_so_path_idx = prefix_len;
834 GC_SO_PATH_APPEND(MODULAR_GC_DIR
"librubygc.");
835 GC_SO_PATH_APPEND(gc_so_file);
836 GC_SO_PATH_APPEND(DLEXT);
837 GC_ASSERT(gc_so_path_idx == gc_so_path_size - 1);
838#undef GC_SO_PATH_APPEND
841 handle = dlopen(gc_so_path, RTLD_LAZY | RTLD_GLOBAL);
843 fprintf(stderr,
"ruby_modular_gc_init: Shared library %s cannot be opened: %s\n", gc_so_path, dlerror());
847 gc_functions.modular_gc_loaded_p =
true;
850 unsigned int err_count = 0;
852# define load_modular_gc_func(name) do { \
854 const char *func_name = "rb_gc_impl_" #name; \
855 gc_functions.name = dlsym(handle, func_name); \
856 if (!gc_functions.name) { \
857 fprintf(stderr, "ruby_modular_gc_init: %s function not exported by library %s\n", func_name, gc_so_path); \
862 gc_functions.name = rb_gc_impl_##name; \
867 load_modular_gc_func(objspace_alloc);
868 load_modular_gc_func(objspace_init);
869 load_modular_gc_func(ractor_cache_alloc);
870 load_modular_gc_func(objspace_retire_gc);
871 load_modular_gc_func(set_params);
872 load_modular_gc_func(init);
874 load_modular_gc_func(shutdown_free_objects);
875 load_modular_gc_func(objspace_free);
876 load_modular_gc_func(ractor_cache_free);
878 load_modular_gc_func(start);
879 load_modular_gc_func(during_gc_p);
880 load_modular_gc_func(prepare_heap);
881 load_modular_gc_func(gc_enable);
882 load_modular_gc_func(gc_disable);
883 load_modular_gc_func(gc_enabled_p);
884 load_modular_gc_func(user_gc_disabled_set);
885 load_modular_gc_func(user_gc_disabled_p);
886 load_modular_gc_func(multi_objspace_p);
887 load_modular_gc_func(during_global_gc_p);
888 load_modular_gc_func(during_postmortem_p);
889 load_modular_gc_func(obj_foreign_p);
890 load_modular_gc_func(objspace_set_ractor);
891 load_modular_gc_func(obj_ractor);
892 load_modular_gc_func(shref_marked_p);
893 load_modular_gc_func(objspace_zombify);
894 load_modular_gc_func(objspace_absorb);
895 load_modular_gc_func(gc_rest);
896 load_modular_gc_func(config_set);
897 load_modular_gc_func(config_get);
898 load_modular_gc_func(stress_set);
899 load_modular_gc_func(stress_get);
900 load_modular_gc_func(get_vm_context);
902 load_modular_gc_func(new_obj);
903 load_modular_gc_func(zjit_new_obj_fastpath);
904 load_modular_gc_func(zjit_writebarrier_required_offset);
905 load_modular_gc_func(obj_slot_size);
906 load_modular_gc_func(size_slot_size);
907 load_modular_gc_func(size_allocatable_p);
908 load_modular_gc_func(max_allocation_size);
910 load_modular_gc_func(malloc);
911 load_modular_gc_func(calloc);
912 load_modular_gc_func(realloc);
913 load_modular_gc_func(free);
914 load_modular_gc_func(adjust_memory_usage);
916 load_modular_gc_func(mark);
917 load_modular_gc_func(mark_and_move);
918 load_modular_gc_func(mark_and_pin);
919 load_modular_gc_func(mark_maybe);
921 load_modular_gc_func(declare_weak_references);
922 load_modular_gc_func(handle_weak_references_alive_p);
924 load_modular_gc_func(register_pinning_obj);
925 load_modular_gc_func(object_moved_p);
926 load_modular_gc_func(pinned_p);
927 load_modular_gc_func(location);
929 load_modular_gc_func(writebarrier);
930 load_modular_gc_func(writebarrier_unprotect);
931 load_modular_gc_func(writebarrier_remember);
932 load_modular_gc_func(obj_became_shareable);
934 load_modular_gc_func(each_objects);
935 load_modular_gc_func(each_objects_shareable);
936 load_modular_gc_func(each_objects_foreign);
937 load_modular_gc_func(each_object);
939 load_modular_gc_func(make_zombie);
940 load_modular_gc_func(define_finalizer);
941 load_modular_gc_func(undefine_finalizer);
942 load_modular_gc_func(copy_finalizer);
943 load_modular_gc_func(shutdown_call_finalizer);
945 load_modular_gc_func(before_fork);
946 load_modular_gc_func(after_fork);
948 load_modular_gc_func(set_measure_total_time);
949 load_modular_gc_func(get_measure_total_time);
950 load_modular_gc_func(get_total_time);
951 load_modular_gc_func(gc_count);
952 load_modular_gc_func(latest_gc_info);
953 load_modular_gc_func(stat);
954 load_modular_gc_func(stat_heap);
955 load_modular_gc_func(active_gc_name);
957 load_modular_gc_func(object_metadata);
958 load_modular_gc_func(live_object_p);
959 load_modular_gc_func(garbage_object_p);
960 load_modular_gc_func(set_event_hook);
961 load_modular_gc_func(copy_attributes);
964 fprintf(stderr,
"ruby_modular_gc_init: found %u missing exports in library %s\n", err_count, gc_so_path);
968# undef load_modular_gc_func
970 rb_gc_functions = gc_functions;
974# define rb_gc_impl_objspace_alloc rb_gc_functions.objspace_alloc
975# define rb_gc_impl_objspace_init rb_gc_functions.objspace_init
976# define rb_gc_impl_ractor_cache_alloc rb_gc_functions.ractor_cache_alloc
977# define rb_gc_impl_objspace_retire_gc rb_gc_functions.objspace_retire_gc
978# define rb_gc_impl_set_params rb_gc_functions.set_params
979# define rb_gc_impl_init rb_gc_functions.init
981# define rb_gc_impl_shutdown_free_objects rb_gc_functions.shutdown_free_objects
982# define rb_gc_impl_objspace_free rb_gc_functions.objspace_free
983# define rb_gc_impl_ractor_cache_free rb_gc_functions.ractor_cache_free
985# define rb_gc_impl_start rb_gc_functions.start
986# define rb_gc_impl_during_gc_p rb_gc_functions.during_gc_p
987# define rb_gc_impl_prepare_heap rb_gc_functions.prepare_heap
988# define rb_gc_impl_gc_enable rb_gc_functions.gc_enable
989# define rb_gc_impl_gc_disable rb_gc_functions.gc_disable
990# define rb_gc_impl_gc_enabled_p rb_gc_functions.gc_enabled_p
991# define rb_gc_impl_user_gc_disabled_set rb_gc_functions.user_gc_disabled_set
992# define rb_gc_impl_user_gc_disabled_p rb_gc_functions.user_gc_disabled_p
993# define rb_gc_impl_multi_objspace_p rb_gc_functions.multi_objspace_p
994# define rb_gc_impl_during_global_gc_p rb_gc_functions.during_global_gc_p
995# define rb_gc_impl_during_postmortem_p rb_gc_functions.during_postmortem_p
996# define rb_gc_impl_obj_foreign_p rb_gc_functions.obj_foreign_p
997# define rb_gc_impl_objspace_set_ractor rb_gc_functions.objspace_set_ractor
998# define rb_gc_impl_obj_ractor rb_gc_functions.obj_ractor
999# define rb_gc_impl_shref_marked_p rb_gc_functions.shref_marked_p
1000# define rb_gc_impl_objspace_zombify rb_gc_functions.objspace_zombify
1001# define rb_gc_impl_objspace_absorb rb_gc_functions.objspace_absorb
1002# define rb_gc_impl_gc_rest rb_gc_functions.gc_rest
1003# define rb_gc_impl_config_get rb_gc_functions.config_get
1004# define rb_gc_impl_config_set rb_gc_functions.config_set
1005# define rb_gc_impl_stress_set rb_gc_functions.stress_set
1006# define rb_gc_impl_stress_get rb_gc_functions.stress_get
1007# define rb_gc_impl_get_vm_context rb_gc_functions.get_vm_context
1009# define rb_gc_impl_new_obj rb_gc_functions.new_obj
1010# define rb_gc_impl_zjit_new_obj_fastpath rb_gc_functions.zjit_new_obj_fastpath
1011# define rb_gc_impl_zjit_writebarrier_required_offset rb_gc_functions.zjit_writebarrier_required_offset
1012# define rb_gc_impl_obj_slot_size rb_gc_functions.obj_slot_size
1013# define rb_gc_impl_size_slot_size rb_gc_functions.size_slot_size
1014# define rb_gc_impl_size_allocatable_p rb_gc_functions.size_allocatable_p
1015# define rb_gc_impl_max_allocation_size rb_gc_functions.max_allocation_size
1017# define rb_gc_impl_malloc rb_gc_functions.malloc
1018# define rb_gc_impl_calloc rb_gc_functions.calloc
1019# define rb_gc_impl_realloc rb_gc_functions.realloc
1020# define rb_gc_impl_free rb_gc_functions.free
1021# define rb_gc_impl_adjust_memory_usage rb_gc_functions.adjust_memory_usage
1023# define rb_gc_impl_mark rb_gc_functions.mark
1024# define rb_gc_impl_mark_and_move rb_gc_functions.mark_and_move
1025# define rb_gc_impl_mark_and_pin rb_gc_functions.mark_and_pin
1026# define rb_gc_impl_mark_maybe rb_gc_functions.mark_maybe
1028# define rb_gc_impl_declare_weak_references rb_gc_functions.declare_weak_references
1029# define rb_gc_impl_handle_weak_references_alive_p rb_gc_functions.handle_weak_references_alive_p
1031# define rb_gc_impl_register_pinning_obj rb_gc_functions.register_pinning_obj
1032# define rb_gc_impl_object_moved_p rb_gc_functions.object_moved_p
1033# define rb_gc_impl_pinned_p rb_gc_functions.pinned_p
1034# define rb_gc_impl_location rb_gc_functions.location
1036# define rb_gc_impl_writebarrier rb_gc_functions.writebarrier
1037# define rb_gc_impl_writebarrier_unprotect rb_gc_functions.writebarrier_unprotect
1038# define rb_gc_impl_writebarrier_remember rb_gc_functions.writebarrier_remember
1039# define rb_gc_impl_obj_became_shareable rb_gc_functions.obj_became_shareable
1041# define rb_gc_impl_each_objects rb_gc_functions.each_objects
1042# define rb_gc_impl_each_objects_shareable rb_gc_functions.each_objects_shareable
1043# define rb_gc_impl_each_objects_foreign rb_gc_functions.each_objects_foreign
1044# define rb_gc_impl_each_object rb_gc_functions.each_object
1046# define rb_gc_impl_make_zombie rb_gc_functions.make_zombie
1047# define rb_gc_impl_define_finalizer rb_gc_functions.define_finalizer
1048# define rb_gc_impl_undefine_finalizer rb_gc_functions.undefine_finalizer
1049# define rb_gc_impl_copy_finalizer rb_gc_functions.copy_finalizer
1050# define rb_gc_impl_shutdown_call_finalizer rb_gc_functions.shutdown_call_finalizer
1052# define rb_gc_impl_before_fork rb_gc_functions.before_fork
1053# define rb_gc_impl_after_fork rb_gc_functions.after_fork
1055# define rb_gc_impl_set_measure_total_time rb_gc_functions.set_measure_total_time
1056# define rb_gc_impl_get_measure_total_time rb_gc_functions.get_measure_total_time
1057# define rb_gc_impl_get_total_time rb_gc_functions.get_total_time
1058# define rb_gc_impl_gc_count rb_gc_functions.gc_count
1059# define rb_gc_impl_latest_gc_info rb_gc_functions.latest_gc_info
1060# define rb_gc_impl_stat rb_gc_functions.stat
1061# define rb_gc_impl_stat_heap rb_gc_functions.stat_heap
1062# define rb_gc_impl_active_gc_name rb_gc_functions.active_gc_name
1064# define rb_gc_impl_object_metadata rb_gc_functions.object_metadata
1065# define rb_gc_impl_live_object_p rb_gc_functions.live_object_p
1066# define rb_gc_impl_garbage_object_p rb_gc_functions.garbage_object_p
1067# define rb_gc_impl_set_event_hook rb_gc_functions.set_event_hook
1068# define rb_gc_impl_copy_attributes rb_gc_functions.copy_attributes
1071#ifdef RUBY_ASAN_ENABLED
1073asan_death_callback(
void)
1076 rb_bug_without_die(
"ASAN error");
1084rb_gc_init_objspaces(
void)
1087 ruby_modular_gc_init();
1090 rb_vm_t *vm = ruby_current_vm_ptr;
1092 void *
objspace = rb_gc_impl_objspace_alloc();
1094 vm->ractor.main_ractor->objspace =
objspace;
1095 rb_gc_impl_objspace_init(
objspace);
1096 rb_gc_objspace_set_ractor(
objspace, vm->ractor.main_ractor);
1097 rb_gc_impl_stress_set(
objspace, initial_stress);
1099#ifdef RUBY_ASAN_ENABLED
1100 __sanitizer_set_death_callback(asan_death_callback);
1107static bool gc_ever_multi_ractor =
false;
1110rb_gc_ever_multi_ractor_p(
void)
1112 return gc_ever_multi_ractor;
1118rb_gc_objspace_alloc(
void)
1122 if (!gc_ever_multi_ractor) gc_ever_multi_ractor =
true;
1123 if (!rb_gc_impl_multi_objspace_p()) {
1125 return rb_gc_get_objspace();
1127 void *
objspace = rb_gc_impl_objspace_alloc();
1128 rb_gc_impl_objspace_init(
objspace);
1136 rb_gc_impl_objspace_free(
objspace);
1140rb_gc_obj_slot_size(
VALUE obj)
1142 return rb_gc_impl_obj_slot_size(obj);
1146gc_validate_pc(
VALUE obj)
1152 rb_execution_context_t *ec = GET_EC();
1153 const rb_control_frame_t *cfp = ec->cfp;
1154 if (cfp && VM_FRAME_RUBYFRAME_P(cfp) && CFP_PC(cfp)) {
1155 const VALUE *iseq_encoded = ISEQ_BODY(CFP_ISEQ(cfp))->iseq_encoded;
1156 const VALUE *iseq_encoded_end = iseq_encoded + ISEQ_BODY(CFP_ISEQ(cfp))->iseq_size;
1157 RUBY_ASSERT(CFP_PC(cfp) >= iseq_encoded,
"PC not set when allocating, breaking tracing");
1158 RUBY_ASSERT(CFP_PC(cfp) <= iseq_encoded_end,
"PC not set when allocating, breaking tracing");
1163NOINLINE(
static void gc_newobj_hook(
VALUE obj));
1165gc_newobj_hook(
VALUE obj)
1167 int lev = RB_GC_VM_LOCK_NO_BARRIER();
1169 size_t slot_size = rb_gc_obj_slot_size(obj);
1170 memset((
char *)obj +
sizeof(
struct RBasic), 0, slot_size -
sizeof(
struct RBasic));
1177 bool gc_disabled =
RTEST(rb_gc_local_disable_no_rest());
1181 if (!gc_disabled) rb_gc_local_enable();
1183 RB_GC_VM_UNLOCK_NO_BARRIER(lev);
1186ALWAYS_INLINE(
static VALUE newobj_body(rb_ractor_t *cr,
void *
objspace,
VALUE klass,
VALUE flags, shape_id_t shape_id,
bool wb_protected,
size_t size));
1192newobj_body(rb_ractor_t *cr,
void *
objspace,
VALUE klass,
VALUE flags, shape_id_t shape_id,
bool wb_protected,
size_t size)
1195 size_t actual_alloc_size;
1196 VALUE obj = rb_gc_impl_new_obj(
objspace, cr->newobj_cache, klass, flags, wb_protected, size, &actual_alloc_size);
1198 GC_ASSERT(actual_alloc_size >= size);
1199 shape_id = rb_shape_transition_slot_size(shape_id, actual_alloc_size);
1201 RBASIC_SET_FULL_SHAPE_ID_NO_CHECKS(obj, shape_id);
1203 gc_validate_pc(obj);
1206 gc_newobj_hook(obj);
1209 if (RUBY_DTRACE_GC_OBJ_NEW_ENABLED()) {
1210 RUBY_DTRACE_GC_OBJ_NEW((
void*)obj, flags);
1213#if RGENGC_CHECK_MODE
1214# ifndef GC_DEBUG_SLOT_FILL_SPECIAL_VALUE
1215# define GC_DEBUG_SLOT_FILL_SPECIAL_VALUE 255
1219 (
void *)(obj +
sizeof(
struct RBasic)),
1220 GC_DEBUG_SLOT_FILL_SPECIAL_VALUE,
1221 rb_gc_obj_slot_size(obj) -
sizeof(
struct RBasic)
1229rb_newobj(rb_execution_context_t *ec,
VALUE klass,
VALUE flags, shape_id_t shape_id,
bool wb_protected,
size_t size)
1233 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
1234 return newobj_body(cr, cr->objspace, klass, flags, shape_id, wb_protected, size);
1250rb_newobj_in_objspace(rb_execution_context_t *ec,
void *
objspace,
VALUE klass,
VALUE flags, shape_id_t shape_id,
bool wb_protected,
size_t size)
1252 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
1254 return newobj_body(cr,
objspace, klass, flags, shape_id, wb_protected, size);
1258rb_ec_newobj_of(rb_execution_context_t *ec,
VALUE klass,
VALUE flags,
size_t size)
1268 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
1269 return newobj_body(cr, cr->objspace, klass, flags, ROOT_SHAPE_ID | SHAPE_ID_LAYOUT_OTHER,
true, size);
1273rb_newobj_of_with_shape(
VALUE klass,
VALUE flags, shape_id_t shape_id,
size_t size)
1275 return rb_newobj(GET_EC(), klass, flags, shape_id,
true, size);
1279rb_newobj_of(
VALUE klass,
VALUE flags,
size_t size)
1281 return rb_newobj(GET_EC(), klass, flags, ROOT_SHAPE_ID | SHAPE_ID_LAYOUT_OTHER,
true, size);
1285VALUE class_allocate_complex_instance(
VALUE klass, uint32_t capacity)
1287 VALUE obj = rb_newobj_of_with_shape(klass,
T_OBJECT, rb_shape_transition_extended(ROOT_COMPLEX_SHAPE_ID),
sizeof(
struct RObject));
1291 VALUE fields_obj = rb_imemo_fields_new_complex(obj, ROOT_COMPLEX_SHAPE_ID, capacity,
false);
1292 ROBJECT_SET_EXTENDED(obj, fields_obj);
1297robject_embedded_size(uint32_t fields_count)
1299 size_t size = rb_obj_embedded_size(fields_count);
1300 if (!rb_gc_size_allocatable_p(size)) {
1301 size =
sizeof(
struct RObject);
1307rb_class_allocate_instance_capa(
VALUE klass, attr_index_t max_iv_count)
1313 if (RB_UNLIKELY(max_iv_count > rb_shape_max_capacity())) {
1314 obj = class_allocate_complex_instance(klass, max_iv_count);
1317 size_t size = robject_embedded_size(max_iv_count);
1321 obj = rb_newobj_of_with_shape(klass,
T_OBJECT, rb_shape_transition_robject(0), size);
1324 VALUE *ptr = ROBJECT_FIELDS(obj);
1325 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1326 attr_index_t fields_count = RSHAPE_LEN(shape_id);
1327 attr_index_t capacity = RSHAPE_CAPACITY(shape_id);
1329 for (attr_index_t i = fields_count; i < capacity; i++) {
1337 rb_bug(
"Expected rb_class_allocate_instance to set the class correctly");
1345rb_class_allocate_instance(
VALUE klass)
1347 return rb_class_allocate_instance_capa(klass, RCLASS_MAX_IV_COUNT(klass));
1352rb_zjit_class_allocate_instance_fastpath(
VALUE klass,
size_t *size_out,
VALUE *flags_out)
1354 uint32_t index_tbl_num_entries = RCLASS_MAX_IV_COUNT(klass);
1357 if (RB_UNLIKELY(index_tbl_num_entries > rb_shape_max_capacity())) {
1361 *size_out = robject_embedded_size(index_tbl_num_entries);
1362 *flags_out =
T_OBJECT | rb_shape_transition_robject(0);
1368rb_zjit_newobj_hook_enabled_p(
void)
1375rb_gc_register_pinning_obj(
VALUE obj)
1377 rb_gc_impl_register_pinning_obj(rb_gc_get_objspace(), obj);
1380#define UNEXPECTED_NODE(func) \
1381 rb_bug(#func"(): GC does not handle T_NODE 0x%x(%p) 0x%"PRIxVALUE, \
1382 BUILTIN_TYPE(obj), (void*)(obj), RBASIC(obj)->flags)
1385rb_data_object_check(
VALUE klass)
1390 rb_warn(
"undefining the allocator of T_DATA class %"PRIsVALUE, klass);
1394#define RTYPEDDATA_EMBEDDED_P rbimpl_typeddata_embedded_p
1395#define RB_DATA_TYPE_EMBEDDABLE_P(type) ((type)->flags & RUBY_TYPED_EMBEDDABLE)
1396#define RTYPEDDATA_EMBEDDABLE_P(obj) RB_DATA_TYPE_EMBEDDABLE_P(RTYPEDDATA_TYPE(obj))
1401 RBIMPL_NONNULL_ARG(
type);
1402 if (klass) rb_data_object_check(klass);
1404 VALUE obj = rb_newobj_in_objspace(GET_EC(),
objspace, klass,
T_DATA, ROOT_SHAPE_ID | SHAPE_ID_LAYOUT_RDATA, wb_protected, size);
1406 rb_gc_register_pinning_obj(obj);
1419 if (UNLIKELY(RB_DATA_TYPE_EMBEDDABLE_P(
type))) {
1420 rb_raise(
rb_eTypeError,
"Cannot wrap an embeddable TypedData");
1429 return typed_data_wrap_in(rb_ec_ractor_ptr(GET_EC())->
objspace, klass, datap,
type);
1435 return typed_data_wrap_in(
objspace, klass, datap,
type);
1441 if (RB_DATA_TYPE_EMBEDDABLE_P(
type)) {
1443 rb_raise(
rb_eTypeError,
"Embeddable TypedData must be freed immediately");
1451 if (rb_gc_size_allocatable_p(embed_size) && !rb_gc_data_type_deferred_free_p(
type)) {
1452 VALUE obj = typed_data_alloc_in(
objspace, klass, TYPED_DATA_EMBEDDED, 0,
type, embed_size);
1453 memset((
char *)obj + offsetof(
struct RTypedData,
data), 0, size);
1466 return typed_data_zalloc_in(rb_ec_ractor_ptr(GET_EC())->
objspace, klass, size,
type);
1472 return typed_data_zalloc_in(
objspace, klass, size,
type);
1476ruby_xmalloc_usable_size(
void *ptr)
1478#ifdef HAVE_MALLOC_USABLE_SIZE
1479#if CALC_EXACT_MALLOC_SIZE
1483 return malloc_usable_size(ptr);
1491rb_objspace_data_type_memsize(
VALUE obj)
1494 const void *ptr = RTYPEDDATA_GET_DATA(obj);
1497 if (RTYPEDDATA_EMBEDDABLE_P(obj) && !RTYPEDDATA_EMBEDDED_P(obj)) {
1498 size += ruby_xmalloc_usable_size((
void *)ptr);
1502 if (
type->function.dsize) {
1503 size +=
type->function.dsize(ptr);
1511rb_objspace_data_type_name(
VALUE obj)
1517rb_gc_declare_weak_references(
VALUE obj)
1519 rb_gc_impl_declare_weak_references(rb_gc_get_objspace(), obj);
1527 return rb_gc_impl_handle_weak_references_alive_p(
objspace, obj);
1531rb_gc_handle_weak_references_alive_p(
void *
objspace,
VALUE obj)
1533 return gc_weak_reference_alive_p(
objspace, obj);
1544 if (
type->function.handle_weak_references) {
1545 (
type->function.handle_weak_references)(RTYPEDDATA_GET_DATA(obj),
objspace);
1549 "rb_gc_handle_weak_references: TypedData %s does not implement handle_weak_references",
1557 switch (imemo_type(obj)) {
1558 case imemo_callcache: {
1560 if (cc->klass !=
Qundef &&
1561 (!gc_weak_reference_alive_p(
objspace, cc->klass) ||
1563 vm_cc_invalidate(cc);
1567 case imemo_subclasses: {
1569 VALUE *entries = rb_imemo_subclasses_entries(obj);
1570 for (uint32_t i = 0; i < subs->count; i++) {
1571 if (entries[i] && !gc_weak_reference_alive_p(
objspace, entries[i])) {
1578 rb_bug(
"rb_gc_handle_weak_references: unexpected imemo type");
1584 rb_bug(
"rb_gc_handle_weak_references: type not supported\n");
1589rb_gc_imemo_needs_cleanup_p(
VALUE obj)
1591 switch (imemo_type(obj)) {
1592 case imemo_constcache:
1597 case imemo_callcache:
1598 case imemo_throw_data:
1599 case imemo_cvar_entry:
1605 case imemo_callinfo:
1609 case imemo_subclasses:
1613 return ((rb_imemo_tmpbuf_t *)obj)->ptr != NULL;
1616 return rb_obj_shape_complex_p(obj);
1634rb_gc_obj_needs_cleanup_p(
VALUE obj)
1641 return rb_gc_imemo_needs_cleanup_p(obj);
1647 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
1648 if (rb_shape_has_fields(shape_id) && rb_shape_layout(shape_id) == SHAPE_ID_LAYOUT_OTHER) {
1673 if (
type & TYPED_DATA_EMBEDDED) {
1683 return (flags & (RSTRING_NOEMBED | RSTRING_FSTR));
1686 return !(flags & RARRAY_EMBED_FLAG);
1689 return (flags & RHASH_ST_TABLE_FLAG);
1692 return (flags & (RMATCH_ONIG | RMATCH_OFFSETS_EXTERNAL)) || USE_DEBUG_COUNTER;
1695 return !(flags & BIGNUM_EMBED_FLAG);
1698 return !(flags & RSTRUCT_EMBED_LEN_MASK);
1705io_fptr_finalize(
void *fptr)
1713 rb_io_t *fptr =
RFILE(obj)->fptr;
1714 rb_gc_impl_make_zombie(
objspace, obj, io_fptr_finalize, fptr);
1720 void *data = RTYPEDDATA_GET_DATA(obj);
1723 void (*dfree)(
void *) =
type->function.dfree;
1726 bool embedded = RTYPEDDATA_EMBEDDED_P(obj);
1728 bool free_embeddable_data = RB_DATA_TYPE_EMBEDDABLE_P(
type) && !embedded;
1733 RB_DEBUG_COUNTER_INC(obj_data_xfree);
1736 else if (free_immediately) {
1738 if (free_embeddable_data) {
1742 RB_DEBUG_COUNTER_INC(obj_data_imm_free);
1745 rb_gc_impl_make_zombie(
objspace, obj, dfree, data);
1746 RB_DEBUG_COUNTER_INC(obj_data_zombie);
1751 RB_DEBUG_COUNTER_INC(obj_data_empty);
1760 rb_objspace_t *objspace;
1764classext_free(rb_classext_t *ext,
bool is_prime,
VALUE box_value,
void *arg)
1768 rb_class_classext_free(args->klass, ext, is_prime);
1772classext_iclass_free(rb_classext_t *ext,
bool is_prime,
VALUE box_value,
void *arg)
1776 rb_iclass_classext_free(args->klass, ext, is_prime);
1784 RB_DEBUG_COUNTER_INC(obj_free);
1788 if (RUBY_DTRACE_GC_OBJ_FREE_ENABLED()) {
1789 RUBY_DTRACE_GC_OBJ_FREE((
void*)obj,
RBASIC(obj)->flags);
1792 switch (builtin_type) {
1797 rb_bug(
"obj_free() called for broken object");
1803 switch (builtin_type) {
1809 rb_zjit_klass_free(obj);
1812 rb_class_classext_foreach(obj, classext_free, (
void *)&args);
1813 if (RCLASS_CLASSEXT_TBL(obj)) {
1814 st_free_table(RCLASS_CLASSEXT_TBL(obj));
1826#if USE_DEBUG_COUNTER
1829 RB_DEBUG_COUNTER_INC(obj_hash_empty);
1832 RB_DEBUG_COUNTER_INC(obj_hash_1);
1835 RB_DEBUG_COUNTER_INC(obj_hash_2);
1838 RB_DEBUG_COUNTER_INC(obj_hash_3);
1841 RB_DEBUG_COUNTER_INC(obj_hash_4);
1847 RB_DEBUG_COUNTER_INC(obj_hash_5_8);
1851 RB_DEBUG_COUNTER_INC(obj_hash_g8);
1854 if (RHASH_AR_TABLE_P(obj)) {
1855 if (RHASH_AR_TABLE(obj) == NULL) {
1856 RB_DEBUG_COUNTER_INC(obj_hash_null);
1859 RB_DEBUG_COUNTER_INC(obj_hash_ar);
1863 RB_DEBUG_COUNTER_INC(obj_hash_st);
1875 onig_free_body(&variant->reg);
1876 SIZED_FREE(variant);
1879 RB_DEBUG_COUNTER_INC(obj_regexp_ptr);
1883 if (!rb_data_free(
objspace, obj))
return false;
1888#if USE_DEBUG_COUNTER
1890 RB_DEBUG_COUNTER_INC(obj_match_ge8);
1893 RB_DEBUG_COUNTER_INC(obj_match_ge4);
1896 RB_DEBUG_COUNTER_INC(obj_match_under4);
1900 onig_region_free(&rm->
as.onig, 0);
1904 RB_DEBUG_COUNTER_INC(obj_match_ptr);
1908 if (
RFILE(obj)->fptr) {
1909 bool closed = rb_io_fptr_finalize_closed(
RFILE(obj)->fptr);
1910 if (!closed) make_io_zombie(
objspace, obj);
1911 RB_DEBUG_COUNTER_INC(obj_file_ptr);
1916 RB_DEBUG_COUNTER_INC(obj_rational);
1919 RB_DEBUG_COUNTER_INC(obj_complex);
1926 rb_class_classext_foreach(obj, classext_iclass_free, (
void *)&args);
1927 if (RCLASS_CLASSEXT_TBL(obj)) {
1928 st_free_table(RCLASS_CLASSEXT_TBL(obj));
1931 RB_DEBUG_COUNTER_INC(obj_iclass_ptr);
1935 RB_DEBUG_COUNTER_INC(obj_float);
1939 if (!BIGNUM_EMBED_P(obj) && BIGNUM_DIGITS(obj)) {
1940 SIZED_FREE_N(BIGNUM_DIGITS(obj), BIGNUM_LEN(obj));
1941 RB_DEBUG_COUNTER_INC(obj_bignum_ptr);
1944 RB_DEBUG_COUNTER_INC(obj_bignum_embed);
1949 UNEXPECTED_NODE(obj_free);
1953 if ((
RBASIC(obj)->flags & RSTRUCT_EMBED_LEN_MASK) ||
1954 RSTRUCT(obj)->
as.heap.ptr == NULL) {
1955 RB_DEBUG_COUNTER_INC(obj_struct_embed);
1958 SIZED_FREE_N(RSTRUCT(obj)->
as.heap.ptr, RSTRUCT(obj)->
as.heap.len);
1959 RB_DEBUG_COUNTER_INC(obj_struct_ptr);
1964 RB_DEBUG_COUNTER_INC(obj_symbol);
1968 rb_imemo_free((
VALUE)obj);
1972 rb_bug(
"gc_sweep(): unknown data type 0x%x(%p) 0x%"PRIxVALUE,
1977 rb_gc_impl_make_zombie(
objspace, obj, 0, 0);
1992 const rb_ractor_t *
const cr = rb_current_ractor_raw(
false);
1993 if (cr != NULL && cr != GET_VM()->ractor.main_ractor) {
1996 rb_gc_impl_set_event_hook(rb_gc_get_objspace(), e);
2000internal_object_p(
VALUE obj)
2002 void *ptr = asan_unpoison_object_temporary(obj);
2004 if (
RBASIC(obj)->flags) {
2007 UNEXPECTED_NODE(internal_object_p);
2016 if (obj == rb_mRubyVMFrozenCore)
2020 if (RCLASS_SINGLETON_P(obj)) {
2021 return rb_singleton_class_internal_p(obj);
2025 if (!
RBASIC(obj)->klass)
break;
2029 if (ptr || !
RBASIC(obj)->flags) {
2030 rb_asan_poison_object(obj);
2036rb_objspace_internal_object_p(
VALUE obj)
2038 return internal_object_p(obj);
2047os_obj_of_i(
void *vstart,
void *vend,
size_t stride,
void *data)
2052 for (; v != (
VALUE)vend; v += stride) {
2053 if (!internal_object_p(v)) {
2073os_shareable_collect_i(
void *vstart,
void *vend,
size_t stride,
void *data)
2078 for (; v != (
VALUE)vend; v += stride) {
2092static void rb_gc_critical_disable(
void);
2093static void rb_gc_critical_enable(
void);
2106 rb_gc_impl_each_objects(rb_gc_get_objspace(), os_obj_of_i, &oes);
2111 if (rb_multi_ractor_p()) {
2116 rb_gc_critical_disable();
2120 void *self = rb_gc_get_objspace();
2121 rb_vm_t *vm = GET_VM();
2123 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
2124 if (r->objspace && r->objspace != self) {
2125 rb_gc_impl_each_objects_shareable(r->objspace, os_shareable_collect_i, &ocs);
2129 rb_gc_critical_enable();
2192 return os_obj_of(of);
2208 return rb_undefine_finalizer(obj);
2214 rb_check_frozen(obj);
2216 rb_gc_impl_undefine_finalizer(rb_gc_get_objspace(), obj);
2222should_be_callable(
VALUE block)
2225 rb_raise(rb_eArgError,
"wrong type argument %"PRIsVALUE
" (should be callable)",
2231should_be_finalizable(
VALUE obj)
2234 rb_raise(rb_eArgError,
"cannot define finalizer for %s",
2237 rb_check_frozen(obj);
2243 rb_gc_impl_copy_finalizer(rb_gc_get_objspace(), dest, obj);
2323 if (rb_callable_receiver(block) == obj) {
2324 rb_warn(
"finalizer references object to be finalized");
2327 return rb_define_finalizer(obj, block);
2333 should_be_finalizable(obj);
2334 should_be_callable(block);
2336 block = rb_gc_impl_define_finalizer(rb_gc_get_objspace(), obj, block);
2344rb_objspace_call_finalizer(
void)
2346 rb_gc_impl_shutdown_call_finalizer(rb_gc_get_objspace());
2350rb_objspace_free_objects(
void *
objspace)
2352 rb_gc_impl_shutdown_free_objects(
objspace);
2356rb_objspace_garbage_object_p(
VALUE obj)
2358 return !
SPECIAL_CONST_P(obj) && rb_gc_impl_garbage_object_p(rb_gc_get_objspace(), obj);
2362rb_objspace_foreign_object_p(
VALUE obj)
2368rb_objspace_live_object_p(
VALUE obj)
2370 return !
SPECIAL_CONST_P(obj) && rb_gc_impl_live_object_p(rb_gc_get_objspace(), (
const void *)obj);
2373#define OBJ_ID_INCREMENT (RUBY_IMMEDIATE_MASK + 1)
2374#define LAST_OBJECT_ID() (object_id_counter * OBJ_ID_INCREMENT)
2376#if SIZEOF_SIZE_T == SIZEOF_LONG_LONG
2377static size_t object_id_counter = 1;
2379static unsigned long long object_id_counter = 1;
2383generate_next_object_id(
void)
2385#if SIZEOF_SIZE_T == SIZEOF_LONG_LONG
2389 unsigned int lock_lev = RB_GC_VM_LOCK();
2390 VALUE id =
ULL2NUM(++object_id_counter * OBJ_ID_INCREMENT);
2391 RB_GC_VM_UNLOCK(lock_lev);
2397class_object_id(
VALUE klass)
2399 VALUE id = RUBY_ATOMIC_VALUE_LOAD(
RCLASS(klass)->object_id);
2401 unsigned int lock_lev = RB_GC_VM_LOCK();
2402 id = generate_next_object_id();
2407 RB_GC_VM_UNLOCK(lock_lev);
2412static inline shape_id_t
2413object_id_field_shape(shape_id_t shape_id)
2415 return rb_shape_complex_p(shape_id) ? ROOT_COMPLEX_WITH_OBJ_ID : rb_shape_object_id(shape_id);
2419object_id_get(
VALUE obj, shape_id_t shape_id)
2421 VALUE id = rb_obj_field_get(obj, object_id_field_shape(shape_id));
2426 rb_bug(
"Object's shape includes object_id, but it's missing %s", rb_obj_info(obj));
2434object_id0(
VALUE obj)
2437 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
2439 if (rb_shape_has_object_id(shape_id)) {
2440 return object_id_get(obj, shape_id);
2443 shape_id_t object_id_shape_id = rb_obj_shape_transition_object_id(obj);
2445 id = generate_next_object_id();
2446 rb_obj_field_set(obj, object_id_shape_id, 0,
id);
2456shareable_data_object_id(
VALUE obj)
2458 VALUE fields_obj = RUBY_ATOMIC_VALUE_LOAD(
RTYPEDDATA(obj)->fields_obj);
2459 if (!fields_obj)
return Qfalse;
2461 shape_id_t shape_id = RBASIC_SHAPE_ID(fields_obj);
2462 if (!rb_shape_has_object_id(shape_id))
return Qfalse;
2464 return rb_imemo_fields_field_get(fields_obj, object_id_field_shape(shape_id));
2476 return class_object_id(obj);
2486 VALUE existing_id = shareable_data_object_id(obj);
2487 if (existing_id)
return existing_id;
2490 unsigned int lock_lev = RB_GC_VM_LOCK();
2491 VALUE id = object_id0(obj);
2492 RB_GC_VM_UNLOCK(lock_lev);
2496 return object_id0(obj);
2500rb_gc_obj_free_vm_weak_references(
VALUE obj)
2507 if (rb_obj_gen_fields_p(obj)) {
2514 rb_gc_free_fstring(obj);
2518 rb_gc_free_dsymbol(obj);
2521 switch (imemo_type(obj)) {
2522 case imemo_callinfo:
2526 rb_free_method_entry_vm_weak_references((
const rb_method_entry_t *)obj);
2541#if SIZEOF_LONG == SIZEOF_VOIDP
2548 return get_heap_object_id(obj);
2552nonspecial_obj_id(
VALUE obj)
2554#if SIZEOF_LONG == SIZEOF_VOIDP
2556#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
2559# error not supported
2566 return rb_find_object_id(NULL, obj, nonspecial_obj_id);
2603 return rb_find_object_id(rb_gc_get_objspace(), obj, object_id);
2607rb_obj_id_p(
VALUE obj)
2619rb_gc_before_updating_jit_code(
void)
2622 rb_yjit_mark_all_writeable();
2625 rb_zjit_mark_all_writable();
2635rb_gc_after_updating_jit_code(
void)
2638 rb_yjit_mark_all_executable();
2641 rb_zjit_mark_all_executable();
2646classext_memsize(rb_classext_t *ext,
bool prime,
VALUE box_value,
void *arg)
2648 size_t *size = (
size_t *)arg;
2651 if (RCLASSEXT_M_TBL(ext)) {
2652 s += rb_id_table_memsize(RCLASSEXT_M_TBL(ext));
2654 if (RCLASSEXT_CONST_TBL(ext)) {
2655 s += rb_id_table_memsize(RCLASSEXT_CONST_TBL(ext));
2657 if (RCLASSEXT_SUPERCLASSES_WITH_SELF(ext)) {
2658 s += (RCLASSEXT_SUPERCLASS_DEPTH(ext) + 1) *
sizeof(
VALUE);
2661 s +=
sizeof(rb_classext_t);
2667classext_superclasses_memsize(rb_classext_t *ext,
bool prime,
VALUE box_value,
void *arg)
2669 size_t *size = (
size_t *)arg;
2671 if (RCLASSEXT_SUPERCLASSES_WITH_SELF(ext)) {
2673 array_size = RCLASSEXT_SUPERCLASS_DEPTH(ext) + 1;
2674 *size += array_size *
sizeof(
VALUE);
2679rb_obj_memsize_of(
VALUE obj)
2692 rb_class_classext_foreach(obj, classext_memsize, (
void *)&size);
2693 rb_class_classext_foreach(obj, classext_superclasses_memsize, (
void *)&size);
2696 if (RICLASS_OWNS_M_TBL_P(obj)) {
2697 if (RCLASS_M_TBL(obj)) {
2698 size += rb_id_table_memsize(RCLASS_M_TBL(obj));
2703 size += rb_str_memsize(obj);
2706 size += rb_ary_memsize(obj);
2709 if (RHASH_ST_TABLE_P(obj)) {
2710 VM_ASSERT(RHASH_ST_TABLE(obj) != NULL);
2712 size += st_memsize(RHASH_ST_TABLE(obj)) -
sizeof(st_table);
2718 size += onig_memsize(
RREGEXP_PTR(obj)) -
sizeof(regex_t);
2720 variant; variant = variant->next) {
2721 size +=
sizeof(*variant) -
sizeof(variant->reg) + onig_memsize(&variant->reg);
2726 size += rb_objspace_data_type_memsize(obj);
2732 size += onig_region_memsize(&rm->
as.onig);
2738 if (
RFILE(obj)->fptr) {
2739 size += rb_io_memsize(
RFILE(obj)->fptr);
2746 size += rb_imemo_memsize(obj);
2754 if (!(
RBASIC(obj)->flags & BIGNUM_EMBED_FLAG) && BIGNUM_DIGITS(obj)) {
2755 size += BIGNUM_LEN(obj) *
sizeof(BDIGIT);
2760 UNEXPECTED_NODE(obj_memsize_of);
2764 if (RSTRUCT_EMBED_LEN(obj) == 0) {
2765 size +=
sizeof(
VALUE) * RSTRUCT_LEN_RAW(obj);
2774 rb_bug(
"objspace/memsize_of(): unknown data type 0x%x(%p)",
2778 return size + rb_gc_obj_slot_size(obj);
2782set_zero(st_data_t key, st_data_t val, st_data_t arg)
2786 rb_hash_aset(hash, k,
INT2FIX(0));
2797count_objects_i(
VALUE obj,
void *d)
2801 if (
RBASIC(obj)->flags) {
2852count_objects(
int argc,
VALUE *argv,
VALUE os)
2864 for (
size_t i = 0; i <=
T_MASK; i++) {
2868 types[i] = type_sym(i);
2875 rb_gc_impl_each_object(rb_gc_get_objspace(), count_objects_i, &data);
2878 hash = rb_hash_new_capa(2 +
T_MASK);
2881 rb_hash_stlike_foreach(hash, set_zero, hash);
2883 rb_hash_aset(hash, total,
SIZET2NUM(data.total));
2884 rb_hash_aset(hash, free,
SIZET2NUM(data.freed));
2886 for (
size_t i = 0; i <=
T_MASK; i++) {
2887 if (data.counts[i]) {
2888 rb_hash_aset(hash, types[i],
SIZET2NUM(data.counts[i]));
2895#define SET_STACK_END SET_MACHINE_STACK_END(&ec->machine.stack_end)
2897#define STACK_START (ec->machine.stack_start)
2898#define STACK_END (ec->machine.stack_end)
2899#define STACK_LEVEL_MAX (ec->machine.stack_maxsize/sizeof(VALUE))
2901#if STACK_GROW_DIRECTION < 0
2902# define STACK_LENGTH (size_t)(STACK_START - STACK_END)
2903#elif STACK_GROW_DIRECTION > 0
2904# define STACK_LENGTH (size_t)(STACK_END - STACK_START + 1)
2906# define STACK_LENGTH ((STACK_END < STACK_START) ? (size_t)(STACK_START - STACK_END) \
2907 : (size_t)(STACK_END - STACK_START + 1))
2909#if !STACK_GROW_DIRECTION
2910int ruby_stack_grow_direction;
2912ruby_get_stack_grow_direction(
volatile VALUE *addr)
2915 SET_MACHINE_STACK_END(&end);
2917 if (end > addr)
return ruby_stack_grow_direction = 1;
2918 return ruby_stack_grow_direction = -1;
2925 rb_execution_context_t *ec = GET_EC();
2927 if (p) *p = STACK_UPPER(STACK_END, STACK_START, STACK_END);
2928 return STACK_LENGTH;
2931#define PREVENT_STACK_OVERFLOW 1
2932#ifndef PREVENT_STACK_OVERFLOW
2933#if !(defined(POSIX_SIGNAL) && defined(SIGSEGV) && defined(HAVE_SIGALTSTACK))
2934# define PREVENT_STACK_OVERFLOW 1
2936# define PREVENT_STACK_OVERFLOW 0
2939#if PREVENT_STACK_OVERFLOW && !defined(__EMSCRIPTEN__)
2941stack_check(rb_execution_context_t *ec,
int water_mark)
2945 size_t length = STACK_LENGTH;
2946 if (STACK_LEVEL_MAX == 0)
return FALSE;
2947 if (STACK_LEVEL_MAX <= (
size_t)water_mark)
return TRUE;
2948 size_t maximum_length = STACK_LEVEL_MAX - water_mark;
2950 return length > maximum_length;
2953#define stack_check(ec, water_mark) FALSE
2956#ifdef RUBY_ASAN_ENABLED
2958# define STACKFRAME_FOR_CALL_CFUNC (128 * 1024 / sizeof(VALUE))
2960# define STACKFRAME_FOR_CALL_CFUNC 2048
2964rb_ec_stack_check(rb_execution_context_t *ec)
2966 return stack_check(ec, STACKFRAME_FOR_CALL_CFUNC);
2972 return stack_check(GET_EC(), STACKFRAME_FOR_CALL_CFUNC);
2981rb_ec_stack_remaining(rb_execution_context_t *ec)
2983#if PREVENT_STACK_OVERFLOW && !defined(__EMSCRIPTEN__)
2984 if (STACK_LEVEL_MAX == 0)
return SIZE_MAX;
2985 if (rb_ec_stack_check(ec))
return 0;
2988 return (STACK_LEVEL_MAX - STACKFRAME_FOR_CALL_CFUNC - STACK_LENGTH) *
sizeof(
VALUE);
3002gc_mark_func_data_slotp_of(rb_ractor_t *
const cr)
3005 return cr != NULL ? &cr->mark_func_data : &GET_VM()->gc.mark_func_data;
3008 return &cr->mark_func_data;
3011#define GC_MARK_FUNC_DATA_SLOTP() gc_mark_func_data_slotp_of(rb_current_ractor_raw(false))
3016static inline struct rb_gc_mark_ctx
3017gc_current_mark_ctx(void)
3019 rb_ractor_t *
const cr = rb_current_ractor_raw(
false);
3020 struct gc_mark_func_data_struct **
const mfdp = gc_mark_func_data_slotp_of(cr);
3022 return (
struct rb_gc_mark_ctx){
3023 .objspace = gc_current_objspace_of(cr),
3028 .checking_shareable = *mfdp != NULL && (*mfdp)->checking_shareable,
3032struct rb_gc_mark_ctx
3033rb_gc_current_mark_ctx(void)
3035 return gc_current_mark_ctx();
3038#define RB_GC_MARK_OR_TRAVERSE(ctx, func, obj_or_ptr, obj, check_obj) do { \
3039 if (!RB_SPECIAL_CONST_P(obj)) { \
3040 struct gc_mark_func_data_struct **mfdp = (ctx)->mfdp; \
3041 struct gc_mark_func_data_struct *mark_func_data = *mfdp; \
3042 void *objspace = (ctx)->objspace; \
3043 if (LIKELY(mark_func_data == NULL)) { \
3044 GC_ASSERT(rb_gc_impl_during_gc_p(objspace)); \
3045 (func)(objspace, (obj_or_ptr)); \
3047 else if (check_obj ? \
3048 rb_gc_impl_live_object_p(objspace, (const void *)obj) && \
3049 !rb_gc_impl_garbage_object_p(objspace, obj) : \
3051 GC_ASSERT(!rb_gc_impl_during_gc_p(objspace)); \
3053 mark_func_data->mark_func((obj), mark_func_data->data); \
3054 *mfdp = mark_func_data; \
3060gc_mark_internal(
const struct rb_gc_mark_ctx *ctx,
VALUE obj)
3062 RB_GC_MARK_OR_TRAVERSE(ctx, rb_gc_impl_mark, obj, obj,
false);
3066gc_mark_and_pin_internal(
const struct rb_gc_mark_ctx *ctx,
VALUE obj)
3068 RB_GC_MARK_OR_TRAVERSE(ctx, rb_gc_impl_mark_and_pin, obj, obj,
false);
3072gc_mark_maybe_internal(
const struct rb_gc_mark_ctx *ctx,
VALUE obj)
3074 RB_GC_MARK_OR_TRAVERSE(ctx, rb_gc_impl_mark_maybe, obj, obj,
true);
3078gc_mark_and_move_internal(
const struct rb_gc_mark_ctx *ctx,
VALUE *ptr)
3080 RB_GC_MARK_OR_TRAVERSE(ctx, rb_gc_impl_mark_and_move, ptr, *ptr,
false);
3088 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3090 gc_mark_internal(&ctx, obj);
3094rb_gc_mark_movable_ctx(
const struct rb_gc_mark_ctx *ctx,
VALUE obj)
3096 gc_mark_internal(ctx, obj);
3104 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3106 gc_mark_and_pin_internal(&ctx, obj);
3110rb_gc_mark_and_pin_ctx(
const struct rb_gc_mark_ctx *ctx,
VALUE obj)
3112 gc_mark_and_pin_internal(ctx, obj);
3120 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3122 gc_mark_maybe_internal(&ctx, obj);
3126rb_gc_mark_maybe_ctx(
const struct rb_gc_mark_ctx *ctx,
VALUE obj)
3128 gc_mark_maybe_internal(ctx, obj);
3132rb_gc_mark_and_move(
VALUE *ptr)
3136 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3138 gc_mark_and_move_internal(&ctx, ptr);
3142rb_gc_mark_and_move_ctx(
const struct rb_gc_mark_ctx *ctx,
VALUE *ptr)
3144 gc_mark_and_move_internal(ctx, ptr);
3147typedef void each_location_func(
const struct rb_gc_mark_ctx *ctx,
VALUE obj,
void *data);
3149ATTRIBUTE_NO_ADDRESS_SAFETY_ANALYSIS(
static void each_location(
const struct rb_gc_mark_ctx *ctx,
register const VALUE *x,
register long n, each_location_func *cb,
void *data));
3151each_location(
const struct rb_gc_mark_ctx *ctx,
register const VALUE *x,
register long n, each_location_func *cb,
void *data)
3162each_location_ptr(
const struct rb_gc_mark_ctx *ctx,
const VALUE *start,
const VALUE *end, each_location_func *cb,
void *data)
3164 if (end <= start)
return;
3165 each_location(ctx, start, end - start, cb, data);
3169gc_mark_maybe_each_location(
const struct rb_gc_mark_ctx *ctx,
VALUE obj,
void *data)
3171 gc_mark_maybe_internal(ctx, obj);
3177 if (end <= start)
return;
3179 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3181 each_location_ptr(&ctx, start, end, gc_mark_maybe_each_location, NULL);
3185rb_gc_mark_locations_ctx(
const struct rb_gc_mark_ctx *ctx,
const VALUE *start,
const VALUE *end)
3187 each_location_ptr(ctx, start, end, gc_mark_maybe_each_location, NULL);
3191rb_gc_mark_values(
long n,
const VALUE *values)
3195 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3197 for (
long i = 0; i < n; i++) {
3198 gc_mark_internal(&ctx, values[i]);
3203rb_gc_mark_vm_stack_values(
long n,
const VALUE *values)
3207 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3209 for (
long i = 0; i < n; i++) {
3210 gc_mark_and_pin_internal(&ctx, values[i]);
3215mark_key(st_data_t key, st_data_t value, st_data_t data)
3217 gc_mark_and_pin_internal((
const struct rb_gc_mark_ctx *)data, (
VALUE)key);
3223rb_mark_set(st_table *tbl)
3227 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3233mark_keyvalue(st_data_t key, st_data_t value, st_data_t data)
3235 const struct rb_gc_mark_ctx *ctx = (
const struct rb_gc_mark_ctx *)data;
3237 gc_mark_internal(ctx, (
VALUE)key);
3238 gc_mark_internal(ctx, (
VALUE)value);
3244pin_key_pin_value(st_data_t key, st_data_t value, st_data_t data)
3246 const struct rb_gc_mark_ctx *ctx = (
const struct rb_gc_mark_ctx *)data;
3248 gc_mark_and_pin_internal(ctx, (
VALUE)key);
3249 gc_mark_and_pin_internal(ctx, (
VALUE)value);
3255pin_key_mark_value(st_data_t key, st_data_t value, st_data_t data)
3257 const struct rb_gc_mark_ctx *ctx = (
const struct rb_gc_mark_ctx *)data;
3259 gc_mark_and_pin_internal(ctx, (
VALUE)key);
3260 gc_mark_internal(ctx, (
VALUE)value);
3266gc_mark_tbl_no_pin_i(st_data_t key, st_data_t value, st_data_t data)
3268 gc_mark_internal((
const struct rb_gc_mark_ctx *)data, (
VALUE)value);
3274gc_mark_set_no_pin_i(st_data_t key, st_data_t value, st_data_t data)
3276 gc_mark_internal((
const struct rb_gc_mark_ctx *)data, (
VALUE)key);
3282mark_hash(
const struct rb_gc_mark_ctx *ctx,
VALUE hash)
3284 if (rb_hash_compare_by_id_p(hash)) {
3285 rb_hash_stlike_foreach(hash, pin_key_mark_value, (st_data_t)ctx);
3288 rb_hash_stlike_foreach(hash, mark_keyvalue, (st_data_t)ctx);
3291 gc_mark_internal(ctx, RHASH(hash)->ifnone);
3295rb_mark_hash(st_table *tbl)
3299 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3301 st_foreach(tbl, pin_key_pin_value, (st_data_t)&ctx);
3304static enum rb_id_table_iterator_result
3305mark_method_entry_i(
VALUE me,
void *data)
3307 gc_mark_internal((
const struct rb_gc_mark_ctx *)data, me);
3309 return ID_TABLE_CONTINUE;
3313mark_m_tbl(
const struct rb_gc_mark_ctx *ctx,
struct rb_id_table *tbl)
3316 rb_id_table_foreach_values(tbl, mark_method_entry_i, (
void *)ctx);
3320static enum rb_id_table_iterator_result
3321mark_const_entry_i(
VALUE value,
void *data)
3323 const rb_const_entry_t *ce = (
const rb_const_entry_t *)value;
3324 const struct rb_gc_mark_ctx *ctx = (
const struct rb_gc_mark_ctx *)data;
3326 gc_mark_internal(ctx, ce->value);
3327 gc_mark_internal(ctx, ce->u.file);
3329 return ID_TABLE_CONTINUE;
3333mark_const_tbl(
const struct rb_gc_mark_ctx *ctx,
struct rb_id_table *tbl)
3336 rb_id_table_foreach_values(tbl, mark_const_entry_i, (
void *)ctx);
3339#if STACK_GROW_DIRECTION < 0
3340#define GET_STACK_BOUNDS(start, end, appendix) ((start) = STACK_END, (end) = STACK_START)
3341#elif STACK_GROW_DIRECTION > 0
3342#define GET_STACK_BOUNDS(start, end, appendix) ((start) = STACK_START, (end) = STACK_END+(appendix))
3344#define GET_STACK_BOUNDS(start, end, appendix) \
3345 ((STACK_END < STACK_START) ? \
3346 ((start) = STACK_END, (end) = STACK_START) : ((start) = STACK_START, (end) = STACK_END+(appendix)))
3350gc_mark_machine_stack_location_maybe(
const struct rb_gc_mark_ctx *ctx,
VALUE obj,
void *data)
3352 gc_mark_maybe_internal(ctx, obj);
3354#ifdef RUBY_ASAN_ENABLED
3355 const rb_execution_context_t *ec = (
const rb_execution_context_t *)data;
3356 void *fake_frame_start;
3357 void *fake_frame_end;
3358 bool is_fake_frame = asan_get_fake_stack_extents(
3359 ec->machine.asan_fake_stack_handle, obj,
3360 ec->machine.stack_start, ec->machine.stack_end,
3361 &fake_frame_start, &fake_frame_end
3363 if (is_fake_frame) {
3364 each_location_ptr(ctx, fake_frame_start, fake_frame_end, gc_mark_maybe_each_location, NULL);
3376 return rb_gc_impl_object_moved_p(
objspace, obj);
3386 return rb_gc_impl_location(
objspace, value);
3392 return gc_location_internal(rb_gc_get_objspace(), value);
3396rb_gc_location_ctx(
const struct rb_gc_mark_ctx *ctx,
VALUE value)
3398 return gc_location_internal(ctx->objspace, value);
3405 if (destination != *ptr) {
3413 gc_update_moved_internal(rb_gc_get_objspace(), ptr);
3417rb_gc_update_moved_ctx(
const struct rb_gc_mark_ctx *ctx,
VALUE *ptr)
3419 gc_update_moved_internal(ctx->objspace, ptr);
3422static void gc_mark_machine_context(
const struct rb_gc_mark_ctx *ctx,
const rb_execution_context_t *ec);
3424#if defined(__wasm__)
3427static VALUE *rb_stack_range_tmp[2];
3430rb_mark_locations(
void *begin,
void *end)
3432 rb_stack_range_tmp[0] = begin;
3433 rb_stack_range_tmp[1] = end;
3437rb_gc_save_machine_context(
void)
3442# if defined(__EMSCRIPTEN__)
3445mark_current_machine_context(
const struct rb_gc_mark_ctx *ctx,
const rb_execution_context_t *ec)
3447 emscripten_scan_stack(rb_mark_locations);
3448 each_location_ptr(ctx, rb_stack_range_tmp[0], rb_stack_range_tmp[1], gc_mark_maybe_each_location, NULL);
3450 emscripten_scan_registers(rb_mark_locations);
3451 each_location_ptr(ctx, rb_stack_range_tmp[0], rb_stack_range_tmp[1], gc_mark_maybe_each_location, NULL);
3456mark_current_machine_context(
const struct rb_gc_mark_ctx *ctx, rb_execution_context_t *ec)
3458 VALUE *stack_start, *stack_end;
3460 GET_STACK_BOUNDS(stack_start, stack_end, 1);
3461 each_location_ptr(ctx, stack_start, stack_end, gc_mark_maybe_each_location, NULL);
3463 rb_wasm_scan_locals(rb_mark_locations);
3464 each_location_ptr(ctx, rb_stack_range_tmp[0], rb_stack_range_tmp[1], gc_mark_maybe_each_location, NULL);
3472rb_gc_save_machine_context(
void)
3474 rb_thread_t *thread = GET_THREAD();
3476 RB_VM_SAVE_MACHINE_CONTEXT(thread);
3481mark_current_machine_context(
const struct rb_gc_mark_ctx *ctx,
const rb_execution_context_t *ec)
3483 gc_mark_machine_context(ctx, ec);
3488gc_mark_machine_context(
const struct rb_gc_mark_ctx *ctx,
const rb_execution_context_t *ec)
3490 VALUE *stack_start, *stack_end;
3492 GET_STACK_BOUNDS(stack_start, stack_end, 0);
3493 RUBY_DEBUG_LOG(
"ec->th:%u stack_start:%p stack_end:%p", rb_ec_thread_ptr(ec)->serial, stack_start, stack_end);
3496#ifdef RUBY_ASAN_ENABLED
3498 (rb_execution_context_t *)ec;
3503 each_location_ptr(ctx, stack_start, stack_end, gc_mark_machine_stack_location_maybe, data);
3504 int num_regs =
sizeof(ec->machine.regs)/(
sizeof(
VALUE));
3505 each_location(ctx, (
VALUE*)&ec->machine.regs, num_regs, gc_mark_machine_stack_location_maybe, data);
3509rb_gc_mark_machine_context_ctx(
const struct rb_gc_mark_ctx *ctx,
const rb_execution_context_t *ec)
3511 gc_mark_machine_context(ctx, ec);
3515rb_mark_tbl_i(st_data_t key, st_data_t value, st_data_t data)
3517 gc_mark_and_pin_internal((
const struct rb_gc_mark_ctx *)data, (
VALUE)value);
3523rb_mark_tbl(st_table *tbl)
3525 if (!tbl || tbl->num_entries == 0)
return;
3527 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3529 st_foreach(tbl, rb_mark_tbl_i, (st_data_t)&ctx);
3533gc_mark_tbl_no_pin(
const struct rb_gc_mark_ctx *ctx, st_table *tbl)
3535 if (!tbl || tbl->num_entries == 0)
return;
3537 st_foreach(tbl, gc_mark_tbl_no_pin_i, (st_data_t)ctx);
3541rb_mark_tbl_no_pin(st_table *tbl)
3543 if (!tbl || tbl->num_entries == 0)
return;
3545 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3547 gc_mark_tbl_no_pin(&ctx, tbl);
3551rb_mark_tbl_no_pin_ctx(
const struct rb_gc_mark_ctx *ctx, st_table *tbl)
3553 gc_mark_tbl_no_pin(ctx, tbl);
3557gc_mark_set_no_pin(
const struct rb_gc_mark_ctx *ctx, st_table *tbl)
3559 if (!tbl || tbl->num_entries == 0)
return;
3561 st_foreach(tbl, gc_mark_set_no_pin_i, (st_data_t)ctx);
3565rb_gc_mark_set_no_pin(st_table *tbl)
3567 if (!tbl || tbl->num_entries == 0)
return;
3569 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3571 gc_mark_set_no_pin(&ctx, tbl);
3575rb_gc_mark_set_no_pin_ctx(
const struct rb_gc_mark_ctx *ctx, st_table *tbl)
3577 gc_mark_set_no_pin(ctx, tbl);
3583 return (
type->flags & RUBY_TYPED_DECL_MARKING) != 0;
3586rb_execution_context_t *
3589 void *
objspace = rb_gc_get_objspace();
3591 if (RB_LIKELY(rb_gc_impl_during_gc_p(
objspace))) {
3592 return rb_gc_impl_get_vm_context(
objspace)->ec;
3603rb_gc_mark_registered_addrs(rb_ractor_t *r,
bool need_lock)
3605 if (r->registered_addrs_cnt == 0)
return;
3607 if (rb_gc_impl_during_gc_p(rb_gc_get_objspace())) {
3608 rb_vm_t *vm = GET_VM();
3610 for (
size_t i = 0; i < r->registered_addrs_cnt; i++) {
3611 rb_gc_mark_maybe(*r->registered_addrs[i].addr);
3617 VALUE stack_snap[16];
3618 VALUE *snap = stack_snap;
3619 size_t capa = numberof(stack_snap);
3621 rb_vm_t *vm = GET_VM();
3623 size_t cnt = r->registered_addrs_cnt;
3624 if (RB_UNLIKELY(cnt >
capa)) {
3626 rb_ractor_t *cr = rb_current_ractor_raw(
false);
3627 bool saved_malloc_gc_disabled = cr ? cr->malloc_gc_disabled :
false;
3628 if (cr) cr->malloc_gc_disabled =
true;
3630 if (cr) cr->malloc_gc_disabled = saved_malloc_gc_disabled;
3633 cnt = r->registered_addrs_cnt;
3634 VM_ASSERT(cnt <=
capa);
3636 for (
size_t i = 0; i < cnt; i++) {
3637 snap[i] = *r->registered_addrs[i].addr;
3641 for (
size_t i = 0; i < cnt; i++) {
3642 rb_gc_mark_maybe(snap[i]);
3644 if (snap != stack_snap)
xfree(snap);
3648gc_mark_roots_ctx(
const struct rb_gc_mark_ctx *ctx,
void *
objspace,
const char **categoryp)
3650 rb_execution_context_t *ec = rb_gc_get_ec();
3651 rb_vm_t *vm = rb_ec_vm_ptr(ec);
3653#define MARK_CHECKPOINT(category) do { \
3654 if (categoryp) *categoryp = category; \
3659 const bool global_gc = rb_gc_impl_during_global_gc_p(
objspace) ||
3660 !rb_gc_impl_multi_objspace_p();
3664 MARK_CHECKPOINT(
"ractor");
3667 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
3668 rb_ractor_mark_local_roots(ctx, r);
3669 MARK_CHECKPOINT(
"registered_addrs");
3670 rb_gc_mark_registered_addrs(r,
true);
3671 MARK_CHECKPOINT(
"ractor");
3676 if (vm->ractor.cnt == 0 && vm->ractor.main_ractor) {
3677 rb_ractor_mark_local_roots(ctx, vm->ractor.main_ractor);
3678 MARK_CHECKPOINT(
"registered_addrs");
3679 rb_gc_mark_registered_addrs(vm->ractor.main_ractor,
true);
3680 MARK_CHECKPOINT(
"ractor");
3686 for (
size_t i = 0; i < vm->gc.zombie_objspaces_count; i++) {
3687 rb_ractor_t *owner = vm->gc.zombie_objspaces[i].owner;
3689 rb_gc_mark_vm_stack_values((
long)owner->registered_marks_cnt,
3690 owner->registered_marks);
3691 MARK_CHECKPOINT(
"registered_addrs");
3692 rb_gc_mark_registered_addrs(owner,
true);
3693 MARK_CHECKPOINT(
"ractor");
3700 if (!rb_gc_impl_multi_objspace_p()) {
3703 ccan_list_for_each(&vm->ractor.terminated_set,
tr, vmlr_node) {
3704 rb_gc_mark_vm_stack_values((
long)
tr->registered_marks_cnt,
3705 tr->registered_marks);
3706 MARK_CHECKPOINT(
"registered_addrs");
3707 rb_gc_mark_registered_addrs(
tr,
false);
3708 MARK_CHECKPOINT(
"ractor");
3714 rb_ractor_t *cr = rb_ec_ractor_ptr(ec);
3715 rb_ractor_mark_local_roots(ctx, cr);
3716 MARK_CHECKPOINT(
"registered_addrs");
3717 rb_gc_mark_registered_addrs(cr,
true);
3723 MARK_CHECKPOINT(
"trap_list");
3724 rb_gc_mark_values(RUBY_NSIG, vm->trap_list.cmd);
3726 MARK_CHECKPOINT(
"shareable_p");
3727 rb_ractor_mark_shareable_p_inflight(ctx);
3731 if (global_gc ||
objspace == vm->ractor.main_ractor->objspace) {
3734 MARK_CHECKPOINT(
"end_proc");
3737 MARK_CHECKPOINT(
"vm");
3741 const bool vm_mark_needs_lock = rb_multi_ractor_p() && !global_gc;
3742 unsigned int vm_mark_lock_lev = 0;
3743 if (vm_mark_needs_lock) vm_mark_lock_lev = RB_GC_VM_LOCK_NO_BARRIER();
3746 MARK_CHECKPOINT(
"global_tbl");
3747 rb_gc_mark_global_tbl();
3750 void rb_yjit_root_mark(
void);
3752 if (rb_yjit_enabled_p) {
3753 MARK_CHECKPOINT(
"YJIT");
3754 rb_yjit_root_mark();
3759 void rb_zjit_root_mark(
void);
3760 if (rb_zjit_enabled_p) {
3761 MARK_CHECKPOINT(
"ZJIT");
3762 rb_zjit_root_mark();
3765 if (vm_mark_needs_lock) RB_GC_VM_UNLOCK_NO_BARRIER(vm_mark_lock_lev);
3767 if (global_gc || rb_gc_single_objspace_p()) {
3768 MARK_CHECKPOINT(
"global_symbols");
3769 rb_sym_global_symbols_mark_and_move();
3777 if (!rb_gc_impl_during_postmortem_p(
objspace)) {
3778 MARK_CHECKPOINT(
"machine_context");
3779 mark_current_machine_context(ctx, ec);
3782 MARK_CHECKPOINT(
"finish");
3784#undef MARK_CHECKPOINT
3788rb_gc_mark_roots(
void *
objspace,
const char **categoryp)
3790 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
3792 GC_ASSERT(ctx.objspace ==
objspace);
3793 gc_mark_roots_ctx(&ctx,
objspace, categoryp);
3802gc_mark_classext_module(rb_classext_t *ext,
bool prime,
VALUE box_value,
void *arg)
3805 const struct rb_gc_mark_ctx *ctx =
foreach_arg->ctx;
3807 if (RCLASSEXT_SUPER(ext)) {
3808 gc_mark_internal(ctx, RCLASSEXT_SUPER(ext));
3810 mark_m_tbl(ctx, RCLASSEXT_M_TBL(ext));
3812 gc_mark_internal(ctx, RCLASSEXT_FIELDS_OBJ(ext));
3813 gc_mark_internal(ctx, RCLASSEXT_CVC_TBL(ext));
3815 if (!RCLASSEXT_SHARED_CONST_TBL(ext) && RCLASSEXT_CONST_TBL(ext)) {
3816 mark_const_tbl(ctx, RCLASSEXT_CONST_TBL(ext));
3818 mark_m_tbl(ctx, RCLASSEXT_CALLABLE_M_TBL(ext));
3819 gc_mark_internal(ctx, RCLASSEXT_CC_TBL(ext));
3820 if (RCLASSEXT_SUBCLASSES(ext)) {
3821 gc_mark_internal(ctx, RCLASSEXT_SUBCLASSES(ext));
3823 gc_mark_internal(ctx, RCLASSEXT_CLASSPATH(ext));
3827gc_mark_classext_iclass(rb_classext_t *ext,
bool prime,
VALUE box_value,
void *arg)
3830 const struct rb_gc_mark_ctx *ctx =
foreach_arg->ctx;
3832 if (RCLASSEXT_SUPER(ext)) {
3833 gc_mark_internal(ctx, RCLASSEXT_SUPER(ext));
3835 if (RCLASSEXT_ICLASS_IS_ORIGIN(ext) && !RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext)) {
3836 mark_m_tbl(ctx, RCLASSEXT_M_TBL(ext));
3838 if (RCLASSEXT_INCLUDER(ext)) {
3839 gc_mark_internal(ctx, RCLASSEXT_INCLUDER(ext));
3841 if (RCLASSEXT_MODULE_REFINEMENT_ICLASSES(ext)) {
3842 gc_mark_internal(ctx, RCLASSEXT_MODULE_REFINEMENT_ICLASSES(ext));
3844 mark_m_tbl(ctx, RCLASSEXT_CALLABLE_M_TBL(ext));
3845 gc_mark_internal(ctx, RCLASSEXT_CC_TBL(ext));
3846 if (RCLASSEXT_SUBCLASSES(ext)) {
3847 gc_mark_internal(ctx, RCLASSEXT_SUBCLASSES(ext));
3851#define TYPED_DATA_REFS_OFFSET_LIST(d) (size_t *)(uintptr_t)RTYPEDDATA_TYPE(d)->function.dmark
3854rb_obj_using_gen_fields_table_p(
VALUE obj)
3865 return rb_obj_gen_fields_p(obj);
3869rb_gc_move_obj_during_marking(
VALUE from,
VALUE to)
3871 if (rb_obj_using_gen_fields_table_p(to)) {
3872 rb_mark_generic_ivar(from);
3877gc_mark_children_ctx(
const struct rb_gc_mark_ctx *ctx,
VALUE obj)
3881 if (rb_obj_using_gen_fields_table_p(obj)) {
3882 rb_mark_generic_ivar(obj);
3892 rb_bug(
"rb_gc_mark() called for broken object");
3896 UNEXPECTED_NODE(rb_gc_mark);
3900 rb_imemo_mark_and_move(ctx, obj,
false);
3907 gc_mark_internal(ctx,
RBASIC(obj)->klass);
3912 gc_mark_internal(ctx, RCLASS_ATTACHED_OBJECT(obj));
3916 foreach_args.ctx = ctx;
3917 foreach_args.obj = obj;
3918 rb_class_classext_foreach(obj, gc_mark_classext_module, (
void *)&foreach_args);
3919 if (BOX_USER_P(RCLASS_PRIME_BOX(obj))) {
3920 gc_mark_internal(ctx, RCLASS_PRIME_BOX(obj)->box_object);
3925 foreach_args.ctx = ctx;
3926 foreach_args.obj = obj;
3927 rb_class_classext_foreach(obj, gc_mark_classext_iclass, (
void *)&foreach_args);
3928 if (BOX_USER_P(RCLASS_PRIME_BOX(obj))) {
3929 gc_mark_internal(ctx, RCLASS_PRIME_BOX(obj)->box_object);
3934 if (ARY_SHARED_P(obj)) {
3935 VALUE root = ARY_SHARED_ROOT(obj);
3937 gc_mark_internal(ctx, root);
3943 gc_mark_and_pin_internal(ctx, root);
3950 gc_mark_internal(ctx, ptr[i]);
3956 mark_hash(ctx, obj);
3960 gc_mark_internal(ctx, RSYMBOL(obj)->fstr);
3964 if (STR_SHARED_P(obj)) {
3965 if (STR_EMBED_P(
RSTRING(obj)->as.heap.aux.shared)) {
3970 gc_mark_and_pin_internal(ctx,
RSTRING(obj)->as.heap.aux.shared);
3973 gc_mark_internal(ctx,
RSTRING(obj)->as.heap.aux.shared);
3979 void *
const ptr = RTYPEDDATA_GET_DATA(obj);
3981 gc_mark_internal(ctx,
RTYPEDDATA(obj)->fields_obj);
3985 size_t *offset_list = TYPED_DATA_REFS_OFFSET_LIST(obj);
3987 for (
size_t offset = *offset_list; offset != RUBY_REF_END; offset = *offset_list++) {
3988 gc_mark_internal(ctx, *(
VALUE *)((
char *)ptr + offset));
3993 if (mark_func) (*mark_func)(ptr);
4001 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
4002 if (rb_shape_embedded_p(shape_id)) {
4003 uint32_t
len = RSHAPE_LEN(shape_id);
4006 for (uint32_t i = 0; i <
len; i++) {
4007 gc_mark_internal(ctx, ptr[i]);
4011 if (!ctx->checking_shareable) {
4012 gc_mark_internal(ctx,
ROBJECT(obj)->as.extended);
4019 if (
RFILE(obj)->fptr) {
4020 gc_mark_internal(ctx,
RFILE(obj)->fptr->self);
4021 gc_mark_internal(ctx,
RFILE(obj)->fptr->pathv);
4022 gc_mark_internal(ctx,
RFILE(obj)->fptr->tied_io_for_writing);
4023 gc_mark_internal(ctx,
RFILE(obj)->fptr->writeconv_asciicompat);
4024 gc_mark_internal(ctx,
RFILE(obj)->fptr->writeconv_pre_ecopts);
4025 gc_mark_internal(ctx,
RFILE(obj)->fptr->encs.ecopts);
4026 gc_mark_internal(ctx,
RFILE(obj)->fptr->write_lock);
4027 gc_mark_internal(ctx,
RFILE(obj)->fptr->timeout);
4028 gc_mark_internal(ctx,
RFILE(obj)->fptr->wakeup_mutex);
4033 gc_mark_internal(ctx,
RREGEXP(obj)->src);
4037 gc_mark_internal(ctx,
RMATCH(obj)->regexp);
4039 gc_mark_internal(ctx,
RMATCH(obj)->str);
4044 gc_mark_internal(ctx, RRATIONAL(obj)->num);
4045 gc_mark_internal(ctx, RRATIONAL(obj)->den);
4049 gc_mark_internal(ctx, RCOMPLEX(obj)->real);
4050 gc_mark_internal(ctx, RCOMPLEX(obj)->imag);
4055 const VALUE *
const ptr = RSTRUCT_CONST_PTR(obj);
4058 gc_mark_internal(ctx, ptr[i]);
4061 gc_mark_internal(ctx, RSTRUCT_FIELDS_OBJ(obj));
4070 rb_bug(
"rb_gc_mark(): unknown data type 0x%x(%p) %s",
4072 rb_gc_impl_live_object_p(ctx->objspace, (
void *)obj) ?
"corrupted object" :
"non object");
4079 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
4081 GC_ASSERT(ctx.objspace ==
objspace);
4082 gc_mark_children_ctx(&ctx, obj);
4086rb_gc_obj_optimal_size(
VALUE obj)
4091 size_t size = rb_ary_size_as_embedded(obj);
4092 if (rb_gc_size_allocatable_p(size)) {
4096 return sizeof(
struct RArray);
4101 if (rb_obj_shape_complex_p(obj)) {
4102 return sizeof(
struct RObject);
4105 size_t size = rb_obj_embedded_size(RSHAPE_CAPACITY(RBASIC_SHAPE_ID(obj)));
4106 if (rb_gc_size_allocatable_p(size)) {
4110 return sizeof(
struct RObject);
4116 size_t size = rb_str_size_as_embedded(obj);
4117 if (rb_gc_size_allocatable_p(size)) {
4121 return sizeof(
struct RString);
4127 if (RHASH_AR_TABLE_P(obj)) {
4128 const unsigned bound = RHASH_AR_TABLE_BOUND(obj);
4129 const size_t ar_size = RHASH_AR_SLOT_SIZE(bound);
4130 if (ar_size > RHASH_ST_SLOT_SIZE ||
OBJ_FROZEN(obj)) {
4135 return RHASH_ST_SLOT_SIZE;
4146 rb_gc_impl_writebarrier(rb_gc_get_objspace(), a, b);
4152 rb_gc_impl_writebarrier_unprotect(rb_gc_get_objspace(), obj);
4159rb_gc_writebarrier_remember(
VALUE obj)
4161 rb_gc_impl_writebarrier_remember(rb_gc_get_objspace(), obj);
4167rb_gc_obj_became_shareable(
VALUE obj)
4169 rb_gc_impl_obj_became_shareable(rb_gc_get_objspace(), obj);
4177 rb_gc_impl_copy_attributes(rb_gc_get_objspace(), dest, obj);
4182rb_gc_modular_gc_loaded_p(
void)
4184 return rb_gc_functions.modular_gc_loaded_p;
4188rb_gc_active_gc_name(
void)
4190 const char *gc_name = rb_gc_impl_active_gc_name();
4192 const size_t len = strlen(gc_name);
4193 if (
len > RB_GC_MAX_NAME_LEN) {
4194 rb_bug(
"GC should have a name no more than %d chars long. Currently: %zu (%s)",
4195 RB_GC_MAX_NAME_LEN,
len, gc_name);
4203rb_gc_object_metadata(
VALUE obj)
4205 return rb_gc_impl_object_metadata(rb_gc_get_objspace(), obj);
4211rb_gc_ractor_cache_alloc(rb_ractor_t *ractor)
4213 return rb_gc_impl_ractor_cache_alloc(rb_gc_get_objspace(), ractor);
4217rb_gc_ractor_cache_free(
void *cache)
4219 rb_gc_impl_ractor_cache_free(rb_gc_get_objspace(), cache);
4225#if defined(RUBY_ASAN_ENABLED)
4226 (void)rb_gc_impl_zjit_new_obj_fastpath;
4229 return rb_gc_impl_zjit_new_obj_fastpath(rb_gc_get_objspace(), alloc_size, flags, klass, fastpath);
4234rb_gc_zjit_writebarrier_required_offset(
void)
4236 return rb_gc_impl_zjit_writebarrier_required_offset();
4245 if (rb_gc_impl_live_object_p(rb_gc_get_objspace(), (
void *)obj)) {
4246 rb_vm_register_global_object(obj);
4251gc_registered_addrs_owner(rb_vm_t *vm)
4253 rb_ractor_t *cr = rb_current_ractor_raw(
false);
4256 return vm->ractor.main_ractor;
4264rb_gc_registered_addrs_enroll_without_gc(rb_vm_t *vm, rb_ractor_t *r)
4266 if (r->registered_addrs_listed)
return;
4267 if (vm->gc.registered_addrs.registry_cnt == vm->gc.registered_addrs.registry_capa) {
4268 size_t nc = vm->gc.registered_addrs.registry_capa ? vm->gc.registered_addrs.registry_capa * 2 : 16;
4271 if (!p) rb_bug(
"rb_gc_registered_addrs_enroll_without_gc: out of memory");
4272 vm->gc.registered_addrs.registry = p;
4273 vm->gc.registered_addrs.registry_capa = nc;
4275 vm->gc.registered_addrs.registry[vm->gc.registered_addrs.registry_cnt++] = r;
4276 r->registered_addrs_listed =
true;
4280rb_gc_registered_addrs_unenroll_without_gc(rb_vm_t *vm, rb_ractor_t *r)
4282 if (!r->registered_addrs_listed)
return;
4283 for (
size_t i = 0; i < vm->gc.registered_addrs.registry_cnt; i++) {
4284 if (vm->gc.registered_addrs.registry[i] == r) {
4285 vm->gc.registered_addrs.registry[i] =
4286 vm->gc.registered_addrs.registry[--vm->gc.registered_addrs.registry_cnt];
4290 r->registered_addrs_listed =
false;
4294rb_gc_each_registered_addr(rb_gc_registered_addr_cb func,
void *data)
4296#if !RB_GC_REGISTERED_ADDR_CHECK
4302 rb_vm_t *vm = GET_VM();
4303 for (
size_t i = 0; i < vm->gc.registered_addrs.registry_cnt; i++) {
4304 rb_ractor_t *r = vm->gc.registered_addrs.registry[i];
4305 for (
size_t j = 0; j < r->registered_addrs_cnt; j++) {
4307 func(entry->addr, entry->initial_value, (
void *)r->objspace, data);
4317rb_gc_registered_addr_owned_by_registrant_p(
VALUE *addr,
void *
objspace)
4319 rb_vm_t *vm = GET_VM();
4320 for (
size_t i = 0; i < vm->gc.registered_addrs.registry_cnt; i++) {
4321 rb_ractor_t *r = vm->gc.registered_addrs.registry[i];
4322 if ((
void *)r->objspace !=
objspace)
continue;
4323 for (
size_t j = 0; j < r->registered_addrs_cnt; j++) {
4324 if (r->registered_addrs[j].addr == addr)
return true;
4333rb_gc_obj_in_zombie_objspace_p(
VALUE obj)
4335 ASSERT_vm_locking();
4336 rb_vm_t *vm = GET_VM();
4337 for (
size_t i = 0; i < vm->gc.zombie_objspaces_count; i++) {
4338 if (!rb_gc_impl_obj_foreign_p(vm->gc.zombie_objspaces[i].objspace, obj))
return true;
4344rb_gc_obj_live_in_zombie_objspace_p(
VALUE obj)
4346 ASSERT_vm_locking();
4347 rb_vm_t *vm = GET_VM();
4348 for (
size_t i = 0; i < vm->gc.zombie_objspaces_count; i++) {
4349 if (rb_gc_impl_live_object_p(vm->gc.zombie_objspaces[i].objspace, (
const void *)obj))
return true;
4357 return !rb_gc_impl_obj_foreign_p(
objspace, obj);
4361gc_registered_addrs_remove(rb_ractor_t *r,
VALUE *addr)
4363 for (
size_t i = 0; i < r->registered_addrs_cnt; i++) {
4364 if (r->registered_addrs[i].addr == addr) {
4365 MEMMOVE(&r->registered_addrs[i], &r->registered_addrs[i + 1],
4367 r->registered_addrs_cnt--;
4377 rb_vm_t *vm = GET_VM();
4380 rb_ractor_t *owner = gc_registered_addrs_owner(vm);
4381 if (owner->registered_addrs_cnt == owner->registered_addrs_capa) {
4382 size_t nc = owner->registered_addrs_capa ? owner->registered_addrs_capa * 2 : 64;
4385 if (!p) rb_bug(
"rb_gc_register_address: out of memory");
4386 owner->registered_addrs = p;
4387 owner->registered_addrs_capa = nc;
4391#if RB_GC_REGISTERED_ADDR_CHECK
4392 entry->initial_value = *addr;
4394 owner->registered_addrs_cnt++;
4395 rb_gc_registered_addrs_enroll_without_gc(vm, owner);
4405 rb_vm_t *vm = GET_VM();
4408 rb_ractor_t *cr = rb_current_ractor_raw(
false);
4409 if (cr == NULL) cr = vm->ractor.main_ractor;
4410 if (cr && gc_registered_addrs_remove(cr, addr))
goto done;
4411 for (
size_t i = 0; i < vm->gc.registered_addrs.registry_cnt; i++) {
4412 if (vm->gc.registered_addrs.registry[i] != cr &&
4413 gc_registered_addrs_remove(vm->gc.registered_addrs.registry[i], addr)) {
4424 rb_gc_register_address(var);
4428gc_start_internal(rb_execution_context_t *ec,
VALUE self,
VALUE full_mark,
VALUE immediate_mark,
VALUE immediate_sweep,
VALUE compact,
VALUE global)
4430 rb_gc_impl_start(rb_gc_get_objspace(),
RTEST(full_mark),
RTEST(immediate_mark),
RTEST(immediate_sweep),
RTEST(compact),
RTEST(global));
4437 int (*callback)(
void *,
void *, size_t,
void *);
4442each_objects_foreign_i(
void *
objspace,
void *arg)
4446 rb_gc_impl_each_objects_foreign(
objspace, a->callback, a->data);
4494rb_objspace_each_objects(
int (*callback)(
void *,
void *,
size_t,
void *),
void *data)
4499 void *self = rb_gc_get_objspace();
4500 rb_gc_impl_each_objects(self, callback, data);
4507 rb_gc_vm_each_objspace(each_objects_foreign_i, &arg);
4515rb_gc_vm_each_objspace(
void (*func)(
void *
objspace,
void *data),
void *data)
4517 ASSERT_vm_locking();
4519 rb_vm_t *vm = GET_VM();
4521 ccan_list_for_each(&vm->ractor.set, r, vmlr_node) {
4523 func(r->objspace, data);
4528 if (r->creating_child_objspace) {
4529 func(r->creating_child_objspace, data);
4532 for (
size_t i = 0; i < vm->gc.zombie_objspaces_count; i++) {
4533 func(vm->gc.zombie_objspaces[i].objspace, data);
4541static void gc_orphan_merge_job(
void *unused);
4549 ASSERT_vm_locking();
4550 if (vm->gc.zombie_objspaces_count == vm->gc.zombie_objspaces_capa) {
4551 size_t new_capa = vm->gc.zombie_objspaces_capa ? vm->gc.zombie_objspaces_capa * 2 : 16;
4552 struct rb_objspace_zombie *grown =
4553 realloc(vm->gc.zombie_objspaces, new_capa *
sizeof(
struct rb_objspace_zombie));
4554 if (grown == NULL) rb_bug(
"zombie_objspaces_push: out of memory");
4555 vm->gc.zombie_objspaces = grown;
4556 vm->gc.zombie_objspaces_capa = new_capa;
4558 vm->gc.zombie_objspaces[vm->gc.zombie_objspaces_count++] = (
struct rb_objspace_zombie){
4559 .objspace = objspace,
4560 .owner_slot = owner_slot,
4563 rb_gc_impl_objspace_zombify(
objspace);
4574gc_orphan_merge_pjob_ensure(
void)
4576 if (GET_VM()->gc.orphan_merge_pjob == POSTPONED_JOB_HANDLE_INVALID) {
4578 if (GET_VM()->gc.orphan_merge_pjob == POSTPONED_JOB_HANDLE_INVALID) {
4579 rb_bug(
"Could not preregister postponed job for GC");
4586rb_gc_objspace_retire_gc(
void)
4588 rb_gc_impl_objspace_retire_gc(rb_gc_get_objspace());
4592rb_gc_objspace_retire(
void **objspace_slot)
4594 rb_vm_t *vm = GET_VM();
4596 if (!rb_gc_impl_multi_objspace_p()) {
4598 *objspace_slot = NULL;
4604 if (rb_gc_impl_user_gc_disabled_set(*objspace_slot,
false)) {
4609 rb_gc_objspace_set_ractor(*objspace_slot, NULL);
4610 gc_orphan_merge_pjob_ensure();
4616 zombie_objspaces_push(vm, *objspace_slot, objspace_slot, owner);
4624rb_gc_objspace_disown(
void *
objspace)
4626 if (!rb_gc_impl_multi_objspace_p())
return;
4627 ASSERT_vm_locking();
4628 rb_vm_t *vm = GET_VM();
4630 rb_gc_objspace_set_ractor(
objspace, NULL);
4632 for (
size_t i = 0; i < vm->gc.zombie_objspaces_count; i++) {
4633 if (vm->gc.zombie_objspaces[i].objspace ==
objspace) {
4634 vm->gc.zombie_objspaces[i].owner_slot = NULL;
4637 vm->gc.zombie_objspaces[i].owner = NULL;
4643 zombie_objspaces_push(vm,
objspace, NULL, NULL);
4648 gc_orphan_merge_pjob_ensure();
4649 rb_postponed_job_trigger_for_ractor(GET_VM()->gc.orphan_merge_pjob, vm->ractor.main_ractor->pub.self);
4655rb_gc_during_global_gc_p(
void)
4657 return rb_gc_impl_during_global_gc_p(rb_gc_get_objspace());
4661rb_gc_vm_forget_zombie(
void *
objspace)
4663 ASSERT_vm_locking();
4664 rb_vm_t *vm = GET_VM();
4665 size_t n = vm->gc.zombie_objspaces_count;
4666 for (
size_t i = 0; i < n; i++) {
4667 if (vm->gc.zombie_objspaces[i].objspace ==
objspace) {
4668 vm->gc.zombie_objspaces[i] = vm->gc.zombie_objspaces[n - 1];
4669 vm->gc.zombie_objspaces_count = n - 1;
4677rb_gc_vm_ractor_count(
void)
4679 return GET_VM()->ractor.cnt;
4688 rb_gc_impl_gc_rest(rb_gc_get_objspace());
4695static int gc_absorbing_zombie = 0;
4700static bool gc_absorbed_since_global_gc =
false;
4703rb_gc_reset_absorbed_since_global_gc(
void)
4705 gc_absorbed_since_global_gc =
false;
4718rb_gc_multi_objspace_p(
void)
4720 return rb_gc_impl_multi_objspace_p();
4726rb_gc_obj_foreign_p(
VALUE obj)
4728 return rb_gc_impl_obj_foreign_p(rb_gc_get_objspace(), obj);
4733rb_gc_objspace_set_ractor(
void *
objspace, rb_ractor_t *r)
4735 rb_gc_impl_objspace_set_ractor(
objspace, r);
4740rb_gc_obj_ractor(
VALUE obj)
4742 return rb_gc_impl_obj_ractor(rb_gc_get_objspace(), obj);
4746rb_gc_single_objspace_p(
void)
4748 if (!rb_gc_impl_multi_objspace_p())
return true;
4749 rb_vm_t *vm = GET_VM();
4752 return (ruby_single_main_ractor != NULL || vm->ractor.cnt == 1) &&
4753 vm->gc.zombie_objspaces_count == 0 && gc_absorbing_zombie == 0 &&
4754 !gc_absorbed_since_global_gc &&
4755 (vm->ractor.main_ractor == NULL ||
4756 vm->ractor.main_ractor->creating_child_objspace == NULL);
4763objspace_absorb_merge(
void *dst,
void *src)
4765 ASSERT_vm_locking();
4766 rb_gc_impl_objspace_absorb(dst, src);
4767 gc_absorbed_since_global_gc =
true;
4774rb_gc_objspace_postmortem_self(
void)
4776 if (!rb_gc_impl_multi_objspace_p())
return;
4778 rb_gc_impl_objspace_retire_gc(rb_gc_get_objspace());
4782rb_gc_objspace_absorb_into_current(
void **objspace_slot)
4784 if (!rb_gc_impl_multi_objspace_p()) {
4785 *objspace_slot = NULL;
4791 *objspace_slot = NULL;
4792 gc_absorbing_zombie++;
4794 objspace_absorb_merge(rb_gc_get_objspace(),
objspace);
4795 gc_absorbing_zombie--;
4804objspace_absorb_disowned_zombies(
void)
4806 rb_vm_t *vm = GET_VM();
4810 while (i < vm->gc.zombie_objspaces_count) {
4811 if (vm->gc.zombie_objspaces[i].owner_slot == NULL) {
4812 void *zombie = vm->gc.zombie_objspaces[i].objspace;
4815 gc_absorbing_zombie++;
4816 rb_gc_vm_forget_zombie(zombie);
4817 objspace_absorb_merge(rb_gc_get_objspace(), zombie);
4818 gc_absorbing_zombie--;
4828gc_orphan_merge_job(
void *unused)
4831 objspace_absorb_disowned_zombies();
4839rb_gc_disable_holders_atfork(
void)
4842 rb_gc_impl_user_gc_disabled_p(rb_gc_get_objspace()) ? 1 : 0);
4846rb_gc_zombie_objspaces_atfork(
void)
4848 rb_vm_t *vm = GET_VM();
4850 for (
size_t i = 0; i < vm->gc.zombie_objspaces_count; i++) {
4851 if (vm->gc.zombie_objspaces[i].owner_slot == NULL) {
4852 rb_postponed_job_trigger_for_ractor(GET_VM()->gc.orphan_merge_pjob, vm->ractor.main_ractor->pub.self);
4862rb_gc_objspace_absorb_all_zombies(
void)
4864 rb_vm_t *vm = GET_VM();
4868 objspace_absorb_disowned_zombies();
4870 while (vm->gc.zombie_objspaces_count > 0) {
4871 size_t before = vm->gc.zombie_objspaces_count;
4872 GC_ASSERT(vm->gc.zombie_objspaces[0].owner_slot != NULL);
4875 rb_ractor_t *owner = vm->gc.zombie_objspaces[0].owner;
4877 rb_ractor_absorb_registered_marks(GET_RACTOR(), owner);
4878 rb_ractor_absorb_registered_addrs_without_gc(GET_RACTOR(), owner);
4880 rb_gc_objspace_absorb_into_current(vm->gc.zombie_objspaces[0].owner_slot);
4881 if (vm->gc.zombie_objspaces_count >= before) {
4882 rb_bug(
"rb_gc_objspace_absorb_all_zombies: zombie list did not shrink");
4890 if (ARY_SHARED_P(v)) {
4891 VALUE old_root =
RARRAY(v)->as.heap.aux.shared_root;
4895 VALUE new_root =
RARRAY(v)->as.heap.aux.shared_root;
4899 if (
RB_TYPE_P(new_root,
T_ARRAY) && ARY_EMBED_P(new_root) && new_root != old_root) {
4900 size_t offset = (size_t)(
RARRAY(v)->as.heap.ptr -
RARRAY(old_root)->as.ary);
4901 GC_ASSERT(
RARRAY(v)->as.heap.ptr >=
RARRAY(old_root)->as.ary);
4902 RARRAY(v)->as.heap.ptr =
RARRAY(new_root)->as.ary + offset;
4915 if (!ARY_EMBED_P(v) && rb_gc_obj_slot_size(v) >= rb_ary_size_as_embedded(v)) {
4919 if (rb_ary_embeddable_p(v) && !rb_gc_impl_pinned_p(
objspace, v)) {
4920 rb_ary_make_embedded(v);
4929 RUBY_ASSERT(rb_gc_obj_slot_size(v) == rb_obj_shape_slot_size(v));
4930 shape_id_t shape_id = RBASIC_SHAPE_ID(v);
4932 if (!rb_shape_embedded_p(shape_id)) {
4935 if (!rb_shape_complex_p(shape_id) && rb_shape_embedded_capacity(shape_id) >= RSHAPE_LEN(shape_id)) {
4936 VALUE *embedded_fields = ROBJECT_EMBEDDED_FIELDS(v);
4937 VALUE *extended_fields = ROBJECT_FIELDS(v);
4938 MEMCPY(embedded_fields, extended_fields,
VALUE, RSHAPE_LEN(shape_id));
4939 shape_id = rb_shape_transition_robject(shape_id);
4940 RBASIC_SET_FULL_SHAPE_ID(v, shape_id);
4941 rb_gc_writebarrier_remember(v);
4948 VALUE *ptr = ROBJECT_FIELDS(v);
4949 attr_index_t
len = RSHAPE_LEN(shape_id);
4950 for (attr_index_t i = 0; i <
len; i++) {
4956rb_gc_ref_update_table_values_only(st_table *tbl)
4958 gc_ref_update_table_values_only(tbl);
4963rb_gc_update_tbl_refs(st_table *ptr)
4965 gc_update_table_refs(ptr);
4969rb_gc_update_set_refs_i(st_data_t key, st_data_t value, st_data_t argp,
int error)
4971 if (rb_gc_location((
VALUE)key) != (
VALUE)key) {
4979rb_gc_update_set_refs_replace_i(st_data_t *key, st_data_t *value, st_data_t argp,
int existing)
4981 rb_gc_update_moved((
VALUE *)key);
4987rb_gc_update_set_refs(st_table *tbl)
4989 if (!tbl || tbl->num_entries == 0)
return;
4991 if (st_foreach_with_replace(tbl, rb_gc_update_set_refs_i, rb_gc_update_set_refs_replace_i, 0)) {
4999 rb_hash_stlike_foreach_with_replace(v, hash_foreach_replace, hash_replace_ref, (st_data_t)
objspace);
5005 for (
long i = 0; i < n; i++) {
5006 UPDATE_IF_MOVED(
objspace, values[i]);
5011rb_gc_update_values(
long n,
VALUE *values)
5013 gc_update_values(rb_gc_get_objspace(), n, values);
5016static enum rb_id_table_iterator_result
5017check_id_table_move(
VALUE value,
void *data)
5022 return ID_TABLE_REPLACE;
5025 return ID_TABLE_CONTINUE;
5029rb_gc_prepare_heap_process_object(
VALUE obj)
5035 rb_enc_str_coderange(obj);
5043rb_gc_prepare_heap(
void)
5045 rb_gc_impl_prepare_heap(rb_gc_get_objspace());
5049rb_gc_size_slot_size(
size_t size)
5051 return rb_gc_impl_size_slot_size(rb_gc_get_objspace(), size);
5055rb_gc_size_allocatable_p(
size_t size)
5057 return rb_gc_impl_size_allocatable_p(size);
5061rb_gc_max_allocation_size(
void)
5063 return rb_gc_impl_max_allocation_size();
5066static enum rb_id_table_iterator_result
5067update_id_table(
VALUE *value,
void *data,
int existing)
5075 return ID_TABLE_CONTINUE;
5082 rb_id_table_foreach_values_with_replace(tbl, check_id_table_move, update_id_table,
objspace);
5086static enum rb_id_table_iterator_result
5089 rb_const_entry_t *ce = (rb_const_entry_t *)value;
5091 if (gc_object_moved_p_internal(
objspace, ce->value)) {
5092 ce->value = gc_location_internal(
objspace, ce->value);
5095 if (gc_object_moved_p_internal(
objspace, ce->u.file)) {
5096 ce->u.file = gc_location_internal(
objspace, ce->u.file);
5099 return ID_TABLE_CONTINUE;
5106 rb_id_table_foreach_values(tbl, update_const_tbl_i,
objspace);
5110update_superclasses(rb_objspace_t *
objspace, rb_classext_t *ext)
5112 if (RCLASSEXT_SUPERCLASSES_WITH_SELF(ext)) {
5113 size_t array_size = RCLASSEXT_SUPERCLASS_DEPTH(ext) + 1;
5114 for (
size_t i = 0; i < array_size; i++) {
5115 UPDATE_IF_MOVED(
objspace, RCLASSEXT_SUPERCLASSES(ext)[i]);
5121update_classext_values(rb_objspace_t *
objspace, rb_classext_t *ext,
bool is_iclass)
5123 UPDATE_IF_MOVED(
objspace, RCLASSEXT_ORIGIN(ext));
5124 UPDATE_IF_MOVED(
objspace, RCLASSEXT_REFINED_CLASS(ext));
5125 UPDATE_IF_MOVED(
objspace, RCLASSEXT_CLASSPATH(ext));
5127 UPDATE_IF_MOVED(
objspace, RCLASSEXT_INCLUDER(ext));
5132update_classext(rb_classext_t *ext,
bool is_prime,
VALUE box_value,
void *arg)
5135 rb_objspace_t *
objspace = args->objspace;
5137 if (RCLASSEXT_SUPER(ext)) {
5138 UPDATE_IF_MOVED(
objspace, RCLASSEXT_SUPER(ext));
5141 update_m_tbl(
objspace, RCLASSEXT_M_TBL(ext));
5143 UPDATE_IF_MOVED(
objspace, ext->fields_obj);
5144 if (!RCLASSEXT_SHARED_CONST_TBL(ext)) {
5145 update_const_tbl(
objspace, RCLASSEXT_CONST_TBL(ext));
5147 UPDATE_IF_MOVED(
objspace, RCLASSEXT_CC_TBL(ext));
5148 UPDATE_IF_MOVED(
objspace, RCLASSEXT_CVC_TBL(ext));
5149 update_superclasses(
objspace, ext);
5150 if (RCLASSEXT_SUBCLASSES(ext)) {
5151 UPDATE_IF_MOVED(
objspace, RCLASSEXT_SUBCLASSES(ext));
5154 update_classext_values(
objspace, ext,
false);
5158update_iclass_classext(rb_classext_t *ext,
bool is_prime,
VALUE box_value,
void *arg)
5161 rb_objspace_t *
objspace = args->objspace;
5163 if (RCLASSEXT_SUPER(ext)) {
5164 UPDATE_IF_MOVED(
objspace, RCLASSEXT_SUPER(ext));
5166 update_m_tbl(
objspace, RCLASSEXT_M_TBL(ext));
5167 update_m_tbl(
objspace, RCLASSEXT_CALLABLE_M_TBL(ext));
5168 UPDATE_IF_MOVED(
objspace, RCLASSEXT_CC_TBL(ext));
5169 UPDATE_IF_MOVED(
objspace, RCLASSEXT_CVC_TBL(ext));
5170 if (RCLASSEXT_SUBCLASSES(ext)) {
5171 UPDATE_IF_MOVED(
objspace, RCLASSEXT_SUBCLASSES(ext));
5174 update_classext_values(
objspace, ext,
true);
5178 vm_table_foreach_callback_func callback;
5179 vm_table_update_callback_func update_callback;
5184 struct st_table *gen_fields_current_tbl;
5188 size_t gf_deferred_cnt, gf_deferred_capa;
5192vm_weak_table_foreach_weak_key(st_data_t key, st_data_t value, st_data_t data,
int error)
5196 int ret = iter_data->callback((
VALUE)key, iter_data->data);
5198 if (!iter_data->weak_only) {
5199 if (ret != ST_CONTINUE)
return ret;
5201 ret = iter_data->callback((
VALUE)value, iter_data->data);
5208vm_weak_table_foreach_update_weak_key(st_data_t *key, st_data_t *value, st_data_t data,
int existing)
5212 int ret = iter_data->update_callback((
VALUE *)key, iter_data->data);
5214 if (!iter_data->weak_only) {
5215 if (ret != ST_CONTINUE)
return ret;
5217 ret = iter_data->update_callback((
VALUE *)value, iter_data->data);
5224vm_weak_table_sym_set_foreach(
VALUE *sym_ptr,
void *data)
5226 VALUE sym = *sym_ptr;
5231 int ret = iter_data->callback(sym, iter_data->data);
5233 if (ret == ST_REPLACE) {
5234 ret = iter_data->update_callback(sym_ptr, iter_data->data);
5240struct st_table *rb_generic_fields_tbl_get(
void);
5243vm_weak_table_gen_fields_foreach(st_data_t key, st_data_t value, st_data_t data)
5247 int ret = iter_data->callback((
VALUE)key, iter_data->data);
5262 RBASIC_SET_SHAPE_ID((
VALUE)key, ROOT_SHAPE_ID);
5267 ret = iter_data->update_callback(&new_key, iter_data->data);
5268 if (key != new_key) {
5275 rb_bug(
"vm_weak_table_gen_fields_foreach: return value %d not supported", ret);
5278 if (!iter_data->weak_only) {
5279 int ivar_ret = iter_data->callback(new_value, iter_data->data);
5285 iter_data->update_callback(&new_value, iter_data->data);
5292 RBASIC_SET_SHAPE_ID((
VALUE)key, ROOT_SHAPE_ID);
5296 rb_bug(
"vm_weak_table_gen_fields_foreach: return value %d not supported", ivar_ret);
5300 if (key != new_key) {
5302 if (iter_data->gf_deferred_cnt == iter_data->gf_deferred_capa) {
5303 size_t nc = iter_data->gf_deferred_capa ? iter_data->gf_deferred_capa * 2 : 64;
5304 struct gen_fields_deferred_insert *p =
5305 realloc(iter_data->gf_deferred, nc *
sizeof(*p));
5306 if (!p) rb_bug(
"vm_weak_table_gen_fields_foreach: out of memory");
5307 iter_data->gf_deferred = p;
5308 iter_data->gf_deferred_capa = nc;
5310 iter_data->gf_deferred[iter_data->gf_deferred_cnt++] =
5311 (
struct gen_fields_deferred_insert){ .k = (st_data_t)new_key, .v = (st_data_t)new_value };
5313 else if (value != new_value) {
5314 DURING_GC_COULD_MALLOC_REGION_START();
5317 st_insert(iter_data->gen_fields_current_tbl, (st_data_t)new_key, new_value);
5319 DURING_GC_COULD_MALLOC_REGION_END();
5326vm_weak_table_frozen_strings_foreach(
VALUE *str,
void *data)
5330 int retval = iter_data->callback(*str, iter_data->data);
5332 if (retval == ST_REPLACE) {
5333 retval = iter_data->update_callback(str, iter_data->data);
5336 if (retval == ST_DELETE) {
5343void rb_fstring_foreach_with_replace(
int (*callback)(
VALUE *str,
void *data),
void *data);
5349vm_weak_table_gen_fields_tbl_cb(
struct st_table *tbl,
void *arg)
5352 foreach_data->gen_fields_current_tbl = tbl;
5353 st_foreach(tbl, vm_weak_table_gen_fields_foreach, (st_data_t)foreach_data);
5357rb_gc_vm_weak_table_foreach(vm_table_foreach_callback_func callback,
5358 vm_table_update_callback_func update_callback,
5361 enum rb_gc_vm_weak_tables table)
5363 rb_vm_t *vm = GET_VM();
5366 .callback = callback,
5367 .update_callback = update_callback,
5369 .weak_only = weak_only,
5373 case RB_GC_VM_CI_TABLE: {
5374 st_foreach_with_replace(
5376 vm_weak_table_foreach_weak_key,
5377 vm_weak_table_foreach_update_weak_key,
5378 (st_data_t)&foreach_data
5382 case RB_GC_VM_OVERLOADED_CME_TABLE: {
5383 st_foreach_with_replace(
5384 &vm->overloaded_cme_table,
5385 vm_weak_table_foreach_weak_key,
5386 vm_weak_table_foreach_update_weak_key,
5387 (st_data_t)&foreach_data
5391 case RB_GC_VM_GLOBAL_SYMBOLS_TABLE: {
5392 rb_sym_global_symbol_table_foreach_weak_reference(
5393 vm_weak_table_sym_set_foreach,
5398 case RB_GC_VM_GENERIC_FIELDS_TABLE: {
5403 if (rb_gc_during_global_gc_p()) {
5404 rb_generic_fields_tables_foreach(vm_weak_table_gen_fields_tbl_cb, (
void *)&foreach_data);
5406 else if (!weak_only) {
5407 rb_generic_fields_shared_table_foreach(vm_weak_table_gen_fields_tbl_cb, (
void *)&foreach_data);
5409 if (foreach_data.gf_deferred != NULL) {
5410 DURING_GC_COULD_MALLOC_REGION_START();
5412 for (
size_t i = 0; i < foreach_data.gf_deferred_cnt; i++) {
5413 struct gen_fields_deferred_insert *
const d = &foreach_data.gf_deferred[i];
5414 st_insert(foreach_data.gen_fields_current_tbl, d->k, d->v);
5417 DURING_GC_COULD_MALLOC_REGION_END();
5418 free(foreach_data.gf_deferred);
5422 case RB_GC_VM_FROZEN_STRINGS_TABLE: {
5423 rb_fstring_foreach_with_replace(
5424 vm_weak_table_frozen_strings_foreach,
5429 case RB_GC_VM_WEAK_TABLE_COUNT:
5430 rb_bug(
"Unreachable");
5432 rb_bug(
"rb_gc_vm_weak_table_foreach: unknown table %d", table);
5444gf_mark_foreach_i(st_data_t key, st_data_t val, st_data_t data)
5447 return ctx->cb((
VALUE)key, (
VALUE)val, ctx->arg);
5451gf_mark_foreach_table_cb(
struct st_table *tbl,
void *arg)
5453 st_foreach(tbl, gf_mark_foreach_i, (st_data_t)arg);
5457rb_gc_vm_generic_fields_mark_foreach(
int (*cb)(
VALUE key,
VALUE val,
void *arg),
void *arg)
5460 rb_generic_fields_tables_foreach(gf_mark_foreach_table_cb, &ctx);
5464 bool (*is_dead)(
VALUE key);
5468gf_drain_i(st_data_t key, st_data_t val, st_data_t data)
5471 if (ctx->is_dead((
VALUE)key)) {
5481gf_drain_table_cb(
struct st_table *tbl,
void *arg)
5487rb_gc_vm_generic_fields_drain_dead(
bool (*is_dead)(
VALUE key))
5490 rb_generic_fields_tables_foreach(gf_drain_table_cb, &ctx);
5494rb_gc_vm_top_self(
void)
5496 return rb_vm_top_self();
5500rb_gc_update_vm_references(
void *
objspace)
5502 rb_execution_context_t *ec = GET_EC();
5503 rb_vm_t *vm = rb_ec_vm_ptr(ec);
5505 rb_vm_update_references(vm);
5506 rb_gc_update_global_tbl();
5507 rb_sym_global_symbols_mark_and_move();
5510 void rb_yjit_root_update_references(
void);
5512 if (rb_yjit_enabled_p) {
5513 rb_yjit_root_update_references();
5518 void rb_zjit_root_update_references(
void);
5520 if (rb_zjit_enabled_p) {
5521 rb_zjit_root_update_references();
5534 UPDATE_IF_MOVED(
objspace, RCLASS_ATTACHED_OBJECT(obj));
5540 rb_class_classext_foreach(obj, update_classext, (
void *)&args);
5545 rb_class_classext_foreach(obj, update_iclass_classext, (
void *)&args);
5553 const struct rb_gc_mark_ctx ctx = gc_current_mark_ctx();
5555 rb_imemo_mark_and_move(&ctx, obj,
true);
5568 gc_ref_update_array(
objspace, obj);
5573 UPDATE_IF_MOVED(
objspace, RHASH(obj)->ifnone);
5578 if (STR_SHARED_P(obj)) {
5586 if (rb_gc_obj_slot_size(obj) >= rb_str_size_as_embedded(obj)) {
5587 if (!STR_EMBED_P(obj) && rb_str_reembeddable_p(obj)
5588 && !rb_gc_impl_pinned_p(
objspace, obj)) {
5589 rb_str_make_embedded(obj);
5598 void *
const ptr = RTYPEDDATA_GET_DATA(obj);
5604 size_t *offset_list = TYPED_DATA_REFS_OFFSET_LIST(obj);
5606 for (
size_t offset = *offset_list; offset != RUBY_REF_END; offset = *offset_list++) {
5607 VALUE *ref = (
VALUE *)((
char *)ptr + offset);
5608 *ref = gc_location_internal(
objspace, *ref);
5613 if (compact_func) (*compact_func)(ptr);
5620 gc_ref_update_object(
objspace, obj);
5624 if (
RFILE(obj)->fptr) {
5627 UPDATE_IF_MOVED(
objspace,
RFILE(obj)->fptr->tied_io_for_writing);
5628 UPDATE_IF_MOVED(
objspace,
RFILE(obj)->fptr->writeconv_asciicompat);
5629 UPDATE_IF_MOVED(
objspace,
RFILE(obj)->fptr->writeconv_pre_ecopts);
5641 UPDATE_IF_MOVED(
objspace, RSYMBOL(obj)->fstr);
5657 UPDATE_IF_MOVED(
objspace, RRATIONAL(obj)->num);
5658 UPDATE_IF_MOVED(
objspace, RRATIONAL(obj)->den);
5662 UPDATE_IF_MOVED(
objspace, RCOMPLEX(obj)->real);
5663 UPDATE_IF_MOVED(
objspace, RCOMPLEX(obj)->imag);
5670 VALUE *ptr = (
VALUE *)RSTRUCT_CONST_PTR(obj);
5672 for (i = 0; i <
len; i++) {
5676 UPDATE_IF_MOVED(
objspace, RSTRUCT(obj)->fields_obj);
5680 rb_bug(
"unreachable");
5697 unless_objspace(
objspace) {
return; }
5699 rb_gc_impl_start(
objspace,
true,
true,
true,
false,
true);
5705 unless_objspace(
objspace) {
return FALSE; }
5707 return rb_gc_impl_during_gc_p(
objspace);
5713 return rb_gc_impl_gc_count(rb_gc_get_objspace());
5717gc_count(rb_execution_context_t *ec,
VALUE self)
5729 VALUE val = rb_gc_impl_latest_gc_info(rb_gc_get_objspace(), key);
5732 rb_raise(rb_eArgError,
"unknown key: %"PRIsVALUE,
rb_sym2str(key));
5739gc_stat(rb_execution_context_t *ec,
VALUE self,
VALUE arg,
VALUE process)
5748 VALUE ret = rb_gc_impl_stat(
RTEST(process) ? NULL : rb_gc_get_objspace(), arg);
5753 rb_raise(rb_eArgError,
"unknown key: %"PRIsVALUE,
rb_sym2str(arg));
5766 VALUE ret = rb_gc_impl_stat(rb_gc_get_objspace(), arg);
5771 rb_raise(rb_eArgError,
"unknown key: %"PRIsVALUE,
rb_sym2str(arg));
5783gc_stat_heap(rb_execution_context_t *ec,
VALUE self,
VALUE heap_name,
VALUE arg)
5789 if (
NIL_P(heap_name)) {
5800 rb_raise(
rb_eTypeError,
"heap_name must be nil or an Integer");
5803 VALUE ret = rb_gc_impl_stat_heap(rb_gc_get_objspace(), heap_name, arg);
5808 rb_raise(rb_eArgError,
"unknown key: %"PRIsVALUE,
rb_sym2str(arg));
5815gc_config_get(rb_execution_context_t *ec,
VALUE self)
5817 VALUE cfg_hash = rb_gc_impl_config_get(rb_gc_get_objspace());
5818 rb_hash_aset(cfg_hash, sym(
"implementation"), rb_fstring_cstr(rb_gc_impl_active_gc_name()));
5824gc_config_set(rb_execution_context_t *ec,
VALUE self,
VALUE hash)
5826 void *
objspace = rb_gc_get_objspace();
5828 rb_gc_impl_config_set(
objspace, hash);
5834gc_stress_get(rb_execution_context_t *ec,
VALUE self)
5836 return rb_gc_impl_stress_get(rb_gc_get_objspace());
5840gc_stress_set_m(rb_execution_context_t *ec,
VALUE self,
VALUE flag)
5842 rb_gc_impl_stress_set(rb_gc_get_objspace(), flag);
5848rb_gc_initial_stress_set(
VALUE flag)
5850 initial_stress = flag;
5858rb_gc_critical_disable(
void)
5860 rb_gc_impl_gc_rest(rb_gc_get_objspace());
5865rb_gc_critical_enable(
void)
5871rb_gc_gc_disabled_global_p(
void)
5879gc_ractor_disable_set(
bool disable)
5881 const bool was = rb_gc_impl_user_gc_disabled_set(rb_gc_get_objspace(), disable);
5882 if (was != disable) {
5896 return RBOOL(gc_ractor_disable_set(
false));
5900rb_gc_disable_no_rest(
void)
5902 return RBOOL(gc_ractor_disable_set(
true));
5908 const bool was_disabled = gc_ractor_disable_set(
true);
5909 if (!was_disabled) {
5910 rb_gc_impl_gc_rest(rb_gc_get_objspace());
5912 return RBOOL(was_disabled);
5916rb_objspace_gc_enable(
void *
objspace)
5918 bool disabled = !rb_gc_impl_gc_enabled_p(
objspace);
5920 return RBOOL(disabled);
5924rb_objspace_gc_disable(
void *
objspace)
5926 bool disabled = !rb_gc_impl_gc_enabled_p(
objspace);
5927 rb_gc_impl_gc_disable(
objspace,
true);
5928 return RBOOL(disabled);
5932rb_gc_objspace_enable(
void *
objspace)
5934 return rb_objspace_gc_enable(
objspace);
5938rb_gc_local_enable(
void)
5940 return rb_gc_objspace_enable(rb_gc_get_objspace());
5945rb_gc_objspace_disable_no_rest(
void *
objspace)
5947 bool disabled = !rb_gc_impl_gc_enabled_p(
objspace);
5948 rb_gc_impl_gc_disable(
objspace,
false);
5949 return RBOOL(disabled);
5953rb_gc_local_disable_no_rest(
void)
5955 return rb_gc_objspace_disable_no_rest(rb_gc_get_objspace());
5959gc_enable(rb_execution_context_t *ec,
VALUE _)
5965gc_disable(rb_execution_context_t *ec,
VALUE _)
5972ruby_gc_set_params(
void)
5974 rb_gc_impl_set_params(rb_gc_get_objspace());
5986reachable_objects_from_body(
VALUE obj,
void (func)(
VALUE,
void *),
void *data,
bool can_run_ruby)
5988 if (rb_gc_impl_during_gc_p(rb_gc_get_objspace()))
5989 rb_bug(
"rb_objspace_reachable_objects_from() is not supported while during GC");
6002 rb_execution_context_t *
volatile ec = GET_EC();
6003 enum ruby_tag_type state;
6006 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
6007 rb_gc_mark_children(rb_gc_get_objspace(), obj);
6013 if (state != TAG_NONE) EC_JUMP_TAG(ec, state);
6016 rb_gc_mark_children(rb_gc_get_objspace(), obj);
6033rb_objspace_reachable_objects_from_unlocked(
VALUE obj,
void (func)(
VALUE,
void *),
void *data)
6035 reachable_objects_from_body(obj, func, data,
false);
6043rb_objspace_reachable_objects_from_local(
VALUE obj,
void (func)(
VALUE,
void *),
void *data)
6045 ASSERT_vm_unlocking();
6046 if (rb_objspace_foreign_object_p(obj)) {
6047 rb_bug(
"rb_objspace_reachable_objects_from_local: %s is owned by another Ractor",
6051 reachable_objects_from_body(obj, func, data,
true);
6057rb_objspace_reachable_objects_from_locked(
VALUE obj,
void (func)(
VALUE,
void *),
void *data)
6059 ASSERT_vm_locking();
6060 reachable_objects_from_body(obj, func, data,
true);
6071rb_objspace_reachable_objects_from(
VALUE obj,
void (func)(
VALUE,
void *),
void *data)
6074 reachable_objects_from_body(obj, func, data,
false);
6079 const char *category;
6080 void (*func)(
const char *category,
VALUE,
void *);
6085root_objects_from(
VALUE obj,
void *ptr)
6088 (*data->func)(data->category, obj, data->data);
6092rb_objspace_reachable_objects_from_root(
void (func)(
const char *category,
VALUE,
void *),
void *passing_data)
6094 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");
6098 .data = passing_data,
6104 .mark_func = root_objects_from,
6109 rb_gc_save_machine_context();
6110 rb_gc_mark_roots(rb_gc_get_objspace(), &data.category);
6122#define TYPE_NAME(t) case (t): return #t;
6149 if (obj && rb_objspace_data_type_name(obj)) {
6150 return rb_objspace_data_type_name(obj);
6159obj_type_name(
VALUE obj)
6161 return type_name(
TYPE(obj), obj);
6165rb_method_type_name(rb_method_type_t
type)
6168 case VM_METHOD_TYPE_ISEQ:
return "iseq";
6169 case VM_METHOD_TYPE_ATTRSET:
return "attrset";
6170 case VM_METHOD_TYPE_IVAR:
return "ivar";
6171 case VM_METHOD_TYPE_BMETHOD:
return "bmethod";
6172 case VM_METHOD_TYPE_ALIAS:
return "alias";
6173 case VM_METHOD_TYPE_REFINED:
return "refined";
6174 case VM_METHOD_TYPE_CFUNC:
return "cfunc";
6175 case VM_METHOD_TYPE_ZSUPER:
return "zsuper";
6176 case VM_METHOD_TYPE_MISSING:
return "missing";
6177 case VM_METHOD_TYPE_OPTIMIZED:
return "optimized";
6178 case VM_METHOD_TYPE_UNDEF:
return "undef";
6179 case VM_METHOD_TYPE_NOTIMPLEMENTED:
return "notimplemented";
6181 rb_bug(
"rb_method_type_name: unreachable (type: %d)",
type);
6185rb_raw_iseq_info(
char *
const buff,
const size_t buff_size,
const rb_iseq_t *iseq)
6187 if (buff_size > 0 && ISEQ_BODY(iseq) && ISEQ_BODY(iseq)->location.label && !
RB_TYPE_P(ISEQ_BODY(iseq)->location.pathobj,
T_MOVED)) {
6188 VALUE path = rb_iseq_path(iseq);
6189 int n = ISEQ_BODY(iseq)->location.first_lineno;
6190 VALUE label = ISEQ_BODY(iseq)->location.label;
6191 snprintf(buff, buff_size,
" %.*s@%.*s:%d",
6198str_len_no_raise(
VALUE str)
6201 if (
len < 0)
return 0;
6202 if (
len > INT_MAX)
return INT_MAX;
6206#define BUFF_ARGS buff + pos, buff_size - pos
6207#define APPEND_F(...) if ((pos += snprintf(BUFF_ARGS, "" __VA_ARGS__)) >= buff_size) goto end
6208#define APPEND_S(s) do { \
6209 if ((pos + (int)rb_strlen_lit(s)) >= buff_size) { \
6213 memcpy(buff + pos, (s), rb_strlen_lit(s) + 1); \
6216#define C(c, s) ((c) != 0 ? (s) : " ")
6219rb_raw_obj_info_common(
char *
const buff,
const size_t buff_size,
const VALUE obj)
6224 APPEND_F(
"%s", obj_type_name(obj));
6230 APPEND_F(
" %s", rb_id2name(
SYM2ID(obj)));
6236 if (rb_gc_impl_live_object_p(rb_gc_get_objspace(), (
void *)obj)) {
6237 APPEND_F(
"%p %s/", (
void *)obj, obj_type_name(obj));
6256 if (internal_object_p(obj)) {
6259 else if (
RBASIC(obj)->klass == 0) {
6260 APPEND_S(
"(temporary internal)");
6264 if (!
NIL_P(class_path)) {
6265 APPEND_F(
"%.*s ", str_len_no_raise(class_path), RSTRING_PTR(class_path));
6274const char *rb_raw_obj_info(
char *
const buff,
const size_t buff_size,
VALUE obj);
6277rb_raw_obj_info_buitin_type(
char *
const buff,
const size_t buff_size,
const VALUE obj,
size_t pos)
6284 UNEXPECTED_NODE(rb_raw_obj_info);
6287 if (ARY_SHARED_P(obj)) {
6288 APPEND_S(
"shared -> ");
6289 rb_raw_obj_info(BUFF_ARGS, ARY_SHARED_ROOT(obj));
6292 APPEND_F(
"[%s%s%s] ",
6293 C(ARY_EMBED_P(obj),
"E"),
6294 C(ARY_SHARED_P(obj),
"S"),
6295 C(ARY_SHARED_ROOT_P(obj),
"R"));
6297 if (ARY_EMBED_P(obj)) {
6298 APPEND_F(
"len: %"PRIdLEN
" (embed)",
6302 APPEND_F(
"len: %"PRIdLEN
", capa:%"PRIdLEN
" ptr:%p",
6304 RARRAY(obj)->as.heap.aux.capa,
6311 C(
FL_TEST(obj, RSTRING_FSTR),
"F"),
6314 if (STR_SHARED_P(obj)) {
6315 APPEND_F(
" [shared] len: %"PRIdLEN, RSTRING_LEN(obj));
6318 if (STR_EMBED_P(obj)) APPEND_S(
" [embed]");
6320 APPEND_F(
" len: %"PRIdLEN
", capa: %" PRIdSIZE, RSTRING_LEN(obj),
rb_str_capacity(obj));
6322 APPEND_F(
" \"%.*s\"", str_len_no_raise(obj), RSTRING_PTR(obj));
6326 VALUE fstr = RSYMBOL(obj)->fstr;
6327 ID id = RSYMBOL(obj)->id;
6329 APPEND_F(
":%.*s id:%d", str_len_no_raise(fstr), RSTRING_PTR(fstr), (
unsigned int)
id);
6332 APPEND_F(
"(%p) id:%d", (
void *)fstr, (
unsigned int)
id);
6337 APPEND_F(
"-> %p", (
void*)gc_location_internal(rb_gc_get_objspace(), obj));
6341 APPEND_F(
"[%c] %"PRIdSIZE,
6342 RHASH_AR_TABLE_P(obj) ?
'A' :
'S',
6350 if (!
NIL_P(class_path)) {
6351 APPEND_F(
"%.*s", str_len_no_raise(class_path), RSTRING_PTR(class_path));
6361 if (!
NIL_P(class_path)) {
6362 APPEND_F(
"src:%.*s", str_len_no_raise(class_path), RSTRING_PTR(class_path));
6368 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
6369 if (rb_shape_embedded_p(shape_id)) {
6370 APPEND_F(
"(embed) len:%d capa:%d", RSHAPE_LEN(shape_id), RSHAPE_CAPACITY(shape_id));
6373 VALUE fields_obj = ROBJECT_FIELDS_OBJ(obj);
6374 if (rb_shape_complex_p(shape_id)) {
6375 size_t hash_len = rb_st_table_size(rb_imemo_fields_complex_tbl(fields_obj));
6376 APPEND_F(
"(complex) len:%zu extended:%p", hash_len, (
void *)fields_obj);
6379 APPEND_F(
"(extended) len:%d capa:%d extended:%p", RSHAPE_LEN(shape_id), RSHAPE_CAPACITY(shape_id), (
void *)fields_obj);
6386 const rb_iseq_t *iseq;
6388 (block = vm_proc_block(obj)) != NULL &&
6389 (vm_block_type(block) == block_type_iseq) &&
6390 (iseq = vm_block_iseq(block)) != NULL) {
6391 rb_raw_iseq_info(BUFF_ARGS, iseq);
6393 else if (rb_ractor_p(obj)) {
6394 rb_ractor_t *r = (
void *)
DATA_PTR(obj);
6396 APPEND_F(
"r:%"PRI_SERIALT_PREFIX
"u", r->pub.id);
6402 APPEND_F(
"<%s> ", rb_imemo_name(imemo_type(obj)));
6404 switch (imemo_type(obj)) {
6407 shape_id_t shape_id = RBASIC_SHAPE_ID(obj);
6408 if (rb_shape_complex_p(shape_id)) {
6409 size_t hash_len = rb_st_table_size(rb_imemo_fields_complex_tbl(obj));
6410 APPEND_F(
"(complex) len:%zu", hash_len);
6413 APPEND_F(
"(embed) len:%d capa:%d", RSHAPE_LEN(shape_id), RSHAPE_CAPACITY(shape_id));
6416 APPEND_S(
"owner -> ");
6417 rb_raw_obj_info(BUFF_ARGS,
CLASS_OF(obj));
6423 const rb_method_entry_t *me = (
const rb_method_entry_t *)obj;
6425 APPEND_F(
":%s (%s%s%s%s) type:%s aliased:%d owner:%p defined_class:%p",
6426 rb_id2name(me->called_id),
6427 METHOD_ENTRY_VISI(me) == METHOD_VISI_PUBLIC ?
"pub" :
6428 METHOD_ENTRY_VISI(me) == METHOD_VISI_PRIVATE ?
"pri" :
"pro",
6429 METHOD_ENTRY_COMPLEMENTED(me) ?
",cmp" :
"",
6430 METHOD_ENTRY_CACHED(me) ?
",cc" :
"",
6431 METHOD_ENTRY_INVALIDATED(me) ?
",inv" :
"",
6432 me->def ? rb_method_type_name(me->def->type) :
"NULL",
6433 me->def ? me->def->aliased : -1,
6435 (
void *)me->defined_class);
6438 switch (me->def->type) {
6439 case VM_METHOD_TYPE_ISEQ:
6440 APPEND_S(
" (iseq:");
6441 rb_raw_obj_info(BUFF_ARGS, (
VALUE)me->def->body.iseq.
iseqptr);
6452 const rb_iseq_t *iseq = (
const rb_iseq_t *)obj;
6453 rb_raw_iseq_info(BUFF_ARGS, iseq);
6456 case imemo_callinfo:
6459 APPEND_F(
"(mid:%s, flag:%x argc:%d, kwarg:%s)",
6460 rb_id2name(vm_ci_mid(ci)),
6463 vm_ci_kwarg(ci) ?
"available" :
"NULL");
6466 case imemo_callcache:
6470 const rb_callable_method_entry_t *cme = vm_cc_cme(cc);
6471 const char *class_name;
6474 if (
NIL_P(class_path)) {
6475 class_name = vm_cc_valid(cc) ?
"??" :
"<NULL>";
6476 class_name_len = vm_cc_valid(cc) ? 2 : 6;
6479 class_name = RSTRING_PTR(class_path);
6480 class_name_len = str_len_no_raise(class_path);
6483 APPEND_F(
"(klass:%.*s cme:%s%s (%p) call:%p",
6484 class_name_len, class_name,
6485 cme ? rb_id2name(cme->called_id) :
"<NULL>",
6486 cme ? (METHOD_ENTRY_INVALIDATED(cme) ?
" [inv]" :
"") :
"",
6488 (
void *)(uintptr_t)vm_cc_call(cc));
6506#ifdef RUBY_ASAN_ENABLED
6508rb_asan_poison_object(
VALUE obj)
6510 MAYBE_UNUSED(
struct RVALUE *) ptr = (
void *)obj;
6511 asan_poison_memory_region(ptr, rb_gc_obj_slot_size(obj));
6515rb_asan_unpoison_object(
VALUE obj,
bool newobj_p)
6517 MAYBE_UNUSED(
struct RVALUE *) ptr = (
void *)obj;
6518 asan_unpoison_memory_region(ptr, rb_gc_obj_slot_size(obj), newobj_p);
6522rb_asan_poisoned_object_p(
VALUE obj)
6524 MAYBE_UNUSED(
struct RVALUE *) ptr = (
void *)obj;
6525 return __asan_region_is_poisoned(ptr, rb_gc_obj_slot_size(obj));
6530raw_obj_info(
char *
const buff,
const size_t buff_size,
VALUE obj)
6532 size_t pos = rb_raw_obj_info_common(buff, buff_size, obj);
6533 pos = rb_raw_obj_info_buitin_type(buff, buff_size, obj, pos);
6534 if (pos >= buff_size) {}
6538rb_raw_obj_info(
char *
const buff,
const size_t buff_size,
VALUE obj)
6540 void *
objspace = rb_gc_get_objspace();
6543 raw_obj_info(buff, buff_size, obj);
6545 else if (!rb_gc_impl_live_object_p(
objspace, (
const void *)obj)) {
6546 snprintf(buff, buff_size,
"out-of-heap:%p", (
void *)obj);
6549 else if (0 && rb_gc_impl_garbage_object_p(
objspace, obj)) {
6550 snprintf(buff, buff_size,
"garbage:%p", (
void *)obj);
6554 asan_unpoisoning_object(obj) {
6555 raw_obj_info(buff, buff_size, obj);
6571 if (RB_UNLIKELY(oldval >= maxval - 1)) {
6582 if (RGENGC_OBJ_INFO) {
6585 char buffers[10][0x100];
6588 rb_atomic_t index = atomic_inc_wraparound(&info.index, numberof(info.buffers));
6589 char *
const buff = info.buffers[index];
6590 return rb_raw_obj_info(buff,
sizeof(info.buffers[0]), obj);
6592 return obj_type_name(obj);
6609 rb_vraise(argv->exc, argv->fmt, *argv->ap);
6614gc_raise(
VALUE exc,
const char *fmt, ...)
6628 fprintf(stderr,
"%s",
"[FATAL] ");
6629 vfprintf(stderr, fmt, ap);
6636NORETURN(
static void negative_size_allocation_error(
const char *));
6638negative_size_allocation_error(
const char *msg)
6644ruby_memerror_body(
void *dummy)
6650NORETURN(
static void ruby_memerror(
void));
6664 fprintf(stderr,
"[FATAL] failed to allocate memory\n");
6681 rb_execution_context_t *ec = GET_EC();
6682 VALUE exc = GET_VM()->special_exceptions[ruby_error_nomemory];
6685 rb_ec_raised_p(ec, RAISED_NOMEMORY) ||
6686 rb_ec_vm_lock_rec(ec) != ec->tag->lock_rec) {
6687 fprintf(stderr,
"[FATAL] failed to allocate memory\n");
6690 if (rb_ec_raised_p(ec, RAISED_NOMEMORY)) {
6691 rb_ec_raised_clear(ec);
6694 rb_ec_raised_set(ec, RAISED_NOMEMORY);
6695 exc = ruby_vm_special_exception_copy(exc);
6698 EC_JUMP_TAG(ec, TAG_RAISE);
6702rb_memerror_reentered(
void)
6704 rb_execution_context_t *ec = GET_EC();
6705 return (ec && rb_ec_raised_p(ec, RAISED_NOMEMORY));
6709handle_malloc_failure(
void *ptr)
6720static void *ruby_xmalloc_body(
size_t size);
6723ruby_xmalloc(
size_t size)
6725 if (RUBY_DTRACE_GC_XMALLOC_ENABLED()) {
6726 RUBY_DTRACE_GC_XMALLOC(1, size);
6729 return handle_malloc_failure(ruby_xmalloc_body(size));
6733malloc_gc_allowed(
void)
6735 rb_ractor_t *r = rb_current_ractor_raw(
false);
6737 return r == NULL || !r->malloc_gc_disabled;
6741ruby_xmalloc_body(
size_t size)
6743 if ((ssize_t)size < 0) {
6744 negative_size_allocation_error(
"too large allocation size");
6747 return rb_gc_impl_malloc(rb_gc_get_objspace(), size, malloc_gc_allowed());
6751ruby_malloc_size_overflow(
size_t count,
size_t elsize)
6753 rb_raise(rb_eArgError,
6754 "malloc: possible integer overflow (%"PRIuSIZE
"*%"PRIuSIZE
")",
6759ruby_malloc_add_size_overflow(
size_t x,
size_t y)
6761 rb_raise(rb_eArgError,
6762 "malloc: possible integer overflow (%"PRIuSIZE
"+%"PRIuSIZE
")",
6766static void *ruby_xmalloc2_body(
size_t n,
size_t size);
6769ruby_xmalloc2(
size_t n,
size_t size)
6771 if (RUBY_DTRACE_GC_XMALLOC_ENABLED()) {
6772 RUBY_DTRACE_GC_XMALLOC(n, size);
6775 return handle_malloc_failure(ruby_xmalloc2_body(n, size));
6779ruby_xmalloc2_body(
size_t n,
size_t size)
6781 return rb_gc_impl_malloc(rb_gc_get_objspace(), xmalloc2_size(n, size), malloc_gc_allowed());
6784static void *ruby_xcalloc_body(
size_t n,
size_t size);
6787ruby_xcalloc(
size_t n,
size_t size)
6789 if (RUBY_DTRACE_GC_XCALLOC_ENABLED()) {
6790 RUBY_DTRACE_GC_XCALLOC(n, size);
6793 return handle_malloc_failure(ruby_xcalloc_body(n, size));
6797ruby_xcalloc_body(
size_t n,
size_t size)
6799 return rb_gc_impl_calloc(rb_gc_get_objspace(), xmalloc2_size(n, size), malloc_gc_allowed());
6802static void *ruby_xrealloc_sized_body(
void *ptr,
size_t new_size,
size_t old_size);
6804#ifdef ruby_xrealloc_sized
6805#undef ruby_xrealloc_sized
6808ruby_xrealloc_sized(
void *ptr,
size_t new_size,
size_t old_size)
6810 return handle_malloc_failure(ruby_xrealloc_sized_body(ptr, new_size, old_size));
6814ruby_xrealloc_sized_body(
void *ptr,
size_t new_size,
size_t old_size)
6816 if ((ssize_t)new_size < 0) {
6817 negative_size_allocation_error(
"too large allocation size");
6820 return rb_gc_impl_realloc(rb_gc_get_objspace(), ptr, new_size, old_size, malloc_gc_allowed());
6824ruby_xrealloc(
void *ptr,
size_t new_size)
6826 return ruby_xrealloc_sized(ptr, new_size, 0);
6829static void *ruby_xrealloc2_sized_body(
void *ptr,
size_t n,
size_t size,
size_t old_n);
6831#ifdef ruby_xrealloc2_sized
6832#undef ruby_xrealloc2_sized
6835ruby_xrealloc2_sized(
void *ptr,
size_t n,
size_t size,
size_t old_n)
6837 return handle_malloc_failure(ruby_xrealloc2_sized_body(ptr, n, size, old_n));
6841ruby_xrealloc2_sized_body(
void *ptr,
size_t n,
size_t size,
size_t old_n)
6843 size_t len = xmalloc2_size(n, size);
6844 return rb_gc_impl_realloc(rb_gc_get_objspace(), ptr,
len, old_n * size, malloc_gc_allowed());
6848ruby_xrealloc2(
void *ptr,
size_t n,
size_t size)
6850 return ruby_xrealloc2_sized(ptr, n, size, 0);
6853#ifdef ruby_xfree_sized
6854#undef ruby_xfree_sized
6864static bool g_nofree =
false;
6868ruby_xfree_sized(
void *x,
size_t size)
6876 if (RUBY_DTRACE_GC_XFREE_ENABLED()) {
6877 RUBY_DTRACE_GC_XFREE(x, size);
6884 if (LIKELY(GET_VM())) {
6885 rb_gc_impl_free(rb_gc_get_objspace(), x, size);
6896 ruby_xfree_sized(x, 0);
6900rb_xmalloc_mul_add(
size_t x,
size_t y,
size_t z)
6902 size_t w = size_mul_add_or_raise(x, y, z, rb_eArgError);
6903 return ruby_xmalloc(w);
6907rb_xcalloc_mul_add(
size_t x,
size_t y,
size_t z)
6909 size_t w = size_mul_add_or_raise(x, y, z, rb_eArgError);
6910 return ruby_xcalloc(w, 1);
6914rb_xrealloc_mul_add(
const void *p,
size_t x,
size_t y,
size_t z)
6916 size_t w = size_mul_add_or_raise(x, y, z, rb_eArgError);
6917 return ruby_xrealloc((
void *)p, w);
6921rb_xmalloc_mul_add_mul(
size_t x,
size_t y,
size_t z,
size_t w)
6923 size_t u = size_mul_add_mul_or_raise(x, y, z, w, rb_eArgError);
6924 return ruby_xmalloc(u);
6928rb_xcalloc_mul_add_mul(
size_t x,
size_t y,
size_t z,
size_t w)
6930 size_t u = size_mul_add_mul_or_raise(x, y, z, w, rb_eArgError);
6931 return ruby_xcalloc(u, 1);
6935# define malloc(n) mi_malloc(n)
6936# define calloc(n, s) mi_calloc(n, s)
6937# define free(p) mi_free(p)
6944ruby_mimmalloc(
size_t size)
6947#if CALC_EXACT_MALLOC_SIZE
6951#if CALC_EXACT_MALLOC_SIZE
6967ruby_mimcalloc(
size_t num,
size_t size)
6970#if CALC_EXACT_MALLOC_SIZE
6971 struct rbimpl_size_overflow_tag t = rbimpl_size_mul_overflow(num, size);
6972 if (UNLIKELY(t.overflowed)) {
6976 mem = calloc1(size);
6988 mem = calloc(num, size);
6994ruby_mimfree(
void *ptr)
6996#if CALC_EXACT_MALLOC_SIZE
7010rb_gc_adjust_memory_usage(ssize_t diff)
7012 unless_objspace(
objspace) {
return; }
7014 rb_gc_impl_adjust_memory_usage(
objspace, diff);
7018rb_obj_info(
VALUE obj)
7020 return obj_info(obj);
7024rb_obj_info_dump(
VALUE obj)
7027 fprintf(stderr,
"rb_obj_info_dump: %s\n", rb_raw_obj_info(buff, 0x100, obj));
7031rb_obj_info_dump_loc(
VALUE obj,
const char *file,
int line,
const char *func)
7034 fprintf(stderr,
"<OBJ_INFO:%s@%s:%d> %s\n", func, file, line, rb_raw_obj_info(buff, 0x100, obj));
7038rb_gc_before_fork(
void)
7040 rb_gc_impl_before_fork(rb_gc_get_objspace());
7044rb_gc_after_fork(rb_pid_t pid)
7046 rb_gc_impl_after_fork(rb_gc_get_objspace(), pid);
7050rb_gc_obj_shareable_p(
VALUE obj)
7067check_shareable_i(
const VALUE child,
void *ptr)
7071 if (!rb_gc_obj_shareable_p(child)) {
7076 if (rb_gc_impl_shref_marked_p(rb_gc_get_objspace(), child)) {
7080 fprintf(stderr,
"(a) ");
7081 rb_gc_rp(data->parent);
7082 fprintf(stderr,
"(b) ");
7084 fprintf(stderr,
"check_shareable_i: shareable (a) -> unshareable (b) without a shref record\n");
7087 rb_bug(
"!! violate shareable constraint !!");
7100rb_gc_verify_shareable(
VALUE obj)
7111 .mark_func = check_shareable_i,
7113 .checking_shareable =
true,
7117 rb_gc_mark_children(rb_gc_get_objspace(), obj);
7121 if (data.err_count > 0) {
7122 rb_bug(
"rb_gc_verify_shareable");
7127rb_gc_checking_shareable(
void)
7130 return mfd && mfd->checking_shareable;
7166 const char* nofree_str = getenv(
"RUBY_NO_FREE");
7167 if (nofree_str && strcmp(nofree_str,
"1") == 0) {
7168 fprintf(stderr,
"WARNING: Enabling no-free mode! xfree() will never free anything!\n");
7174 malloc_offset = gc_compute_malloc_offset();
7176 rb_mGC = rb_define_module(
"GC");
7178 VALUE rb_mObjSpace = rb_define_module(
"ObjectSpace");
7185 rb_vm_register_special_exception(ruby_error_nomemory,
rb_eNoMemError,
"failed to allocate memory");
7208ruby_annotate_mmap(
const void *addr,
unsigned long size,
const char *name)
7210#if defined(HAVE_SYS_PRCTL_H) && defined(PR_SET_VMA) && defined(PR_SET_VMA_ANON_NAME)
7213 prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, (
unsigned long)addr, size, name);
#define RUBY_ATOMIC_VALUE_CAS(var, oldval, newval)
Identical to RUBY_ATOMIC_CAS, except it expects its arguments are VALUE.
#define RUBY_ATOMIC_PTR_LOAD(var)
Identical to RUBY_ATOMIC_LOAD, except it expects its arguments are void*.
#define RUBY_ATOMIC_SIZE_FETCH_ADD(var, val)
Identical to RUBY_ATOMIC_FETCH_ADD, except it expects its arguments to be size_t.
#define RUBY_ATOMIC_INC(var)
Atomically increments the value pointed by var.
#define RUBY_ATOMIC_CAS(var, oldval, newval)
Atomic compare-and-swap.
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
#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...
#define RUBY_ATOMIC_DEC(var)
Atomically decrements the value pointed by var.
#define RUBY_ATOMIC_LOAD(var)
Atomic load.
#define RUBY_ATOMIC_SET(var, val)
Identical to RUBY_ATOMIC_EXCHANGE, except for the return type.
#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.
unsigned int rb_postponed_job_handle_t
The type of a handle returned from rb_postponed_job_preregister and passed to rb_postponed_job_trigge...
void rb_postponed_job_trigger(rb_postponed_job_handle_t h)
Triggers a pre-registered job registered with rb_postponed_job_preregister, scheduling it for executi...
rb_postponed_job_handle_t rb_postponed_job_preregister(unsigned int flags, rb_postponed_job_func_t func, void *data)
Pre-registers a func in Ruby's postponed job preregistration table, returning an opaque handle which ...
#define RUBY_INTERNAL_EVENT_FREEOBJ
Object swept.
uint32_t rb_event_flag_t
Represents event(s).
#define RUBY_INTERNAL_EVENT_NEWOBJ
Object allocated.
static bool RB_OBJ_FROZEN(VALUE obj)
Checks if an object is frozen.
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.
#define T_COMPLEX
Old name of RUBY_T_COMPLEX.
#define TYPE(_)
Old name of rb_type.
#define FL_SINGLETON
Old name of RUBY_FL_SINGLETON.
#define T_FILE
Old name of RUBY_T_FILE.
#define T_STRING
Old name of RUBY_T_STRING.
#define xfree
Old name of ruby_xfree.
#define T_MASK
Old name of RUBY_T_MASK.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define OBJ_FROZEN
Old name of RB_OBJ_FROZEN.
#define T_NIL
Old name of RUBY_T_NIL.
#define UNREACHABLE
Old name of RBIMPL_UNREACHABLE.
#define T_FLOAT
Old name of RUBY_T_FLOAT.
#define T_IMEMO
Old name of RUBY_T_IMEMO.
#define ID2SYM
Old name of RB_ID2SYM.
#define T_BIGNUM
Old name of RUBY_T_BIGNUM.
#define SPECIAL_CONST_P
Old name of RB_SPECIAL_CONST_P.
#define T_STRUCT
Old name of RUBY_T_STRUCT.
#define OBJ_FREEZE
Old name of RB_OBJ_FREEZE.
#define T_FIXNUM
Old name of RUBY_T_FIXNUM.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define SYM2ID
Old name of RB_SYM2ID.
#define T_DATA
Old name of RUBY_T_DATA.
#define FIXNUM_FLAG
Old name of RUBY_FIXNUM_FLAG.
#define LL2NUM
Old name of RB_LL2NUM.
#define CLASS_OF
Old name of rb_class_of.
#define T_NONE
Old name of RUBY_T_NONE.
#define T_NODE
Old name of RUBY_T_NODE.
#define SIZET2NUM
Old name of RB_SIZE2NUM.
#define FL_FINALIZE
Old name of RUBY_FL_FINALIZE.
#define T_MODULE
Old name of RUBY_T_MODULE.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define T_TRUE
Old name of RUBY_T_TRUE.
#define T_RATIONAL
Old name of RUBY_T_RATIONAL.
#define T_ICLASS
Old name of RUBY_T_ICLASS.
#define T_HASH
Old name of RUBY_T_HASH.
#define ALLOC_N
Old name of RB_ALLOC_N.
#define FL_ABLE
Old name of RB_FL_ABLE.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define LONG2NUM
Old name of RB_LONG2NUM.
#define T_FALSE
Old name of RUBY_T_FALSE.
#define ULL2NUM
Old name of RB_ULL2NUM.
#define T_UNDEF
Old name of RUBY_T_UNDEF.
#define T_ZOMBIE
Old name of RUBY_T_ZOMBIE.
#define Qnil
Old name of RUBY_Qnil.
#define Qfalse
Old name of RUBY_Qfalse.
#define FIX2LONG
Old name of RB_FIX2LONG.
#define T_ARRAY
Old name of RUBY_T_ARRAY.
#define T_OBJECT
Old name of RUBY_T_OBJECT.
#define NIL_P
Old name of RB_NIL_P.
#define FL_WB_PROTECTED
Old name of RUBY_FL_WB_PROTECTED.
#define T_SYMBOL
Old name of RUBY_T_SYMBOL.
#define T_MATCH
Old name of RUBY_T_MATCH.
#define T_CLASS
Old name of RUBY_T_CLASS.
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
#define T_MOVED
Old name of RUBY_T_MOVED.
#define FL_TEST
Old name of RB_FL_TEST.
#define xcalloc
Old name of ruby_xcalloc.
#define FL_UNSET
Old name of RB_FL_UNSET.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define NUM2SIZET
Old name of RB_NUM2SIZE.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
#define T_REGEXP
Old name of RUBY_T_REGEXP.
size_t ruby_stack_length(VALUE **p)
Queries what Ruby thinks is the machine stack.
int ruby_stack_check(void)
Checks for stack overflow.
VALUE rb_eNoMemError
NoMemoryError exception.
#define ruby_verbose
This variable controls whether the interpreter is in debug mode.
VALUE rb_eTypeError
TypeError exception.
VALUE rb_eRuntimeError
RuntimeError exception.
void rb_warn(const char *fmt,...)
Identical to rb_warning(), except it reports unless $VERBOSE is nil.
VALUE rb_mKernel
Kernel module.
VALUE rb_cObject
Object class.
VALUE rb_obj_class(VALUE obj)
Queries the class of an object.
VALUE rb_cBasicObject
BasicObject class.
VALUE rb_class_real(VALUE klass)
Finds a "real" class.
VALUE rb_obj_is_kind_of(VALUE obj, VALUE klass)
Queries if the given object is an instance (of possibly descendants) of the given class.
#define RUBY_ASSERT_ALWAYS(expr,...)
A variant of RUBY_ASSERT that does not interface with RUBY_DEBUG.
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
void rb_memerror(void)
Triggers out-of-memory error.
VALUE rb_gc_disable(void)
Disables GC.
VALUE rb_gc_start(void)
Identical to rb_gc(), except the return value.
VALUE rb_gc_enable(void)
(Re-) enables GC.
int rb_during_gc(void)
Queries if the GC is busy.
void rb_gc(void)
Triggers a GC process.
size_t rb_gc_count(void)
Identical to rb_gc_stat(), with "count" parameter.
void rb_ary_free(VALUE ary)
Destroys the given array for no reason.
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
#define RETURN_ENUMERATOR(obj, argc, argv)
Identical to RETURN_SIZED_ENUMERATOR(), except its size is unknown.
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
VALUE rb_hash_new(void)
Creates a new, empty hash object.
VALUE rb_block_proc(void)
Constructs a Proc object from implicitly passed components.
VALUE rb_obj_is_proc(VALUE recv)
Queries if the given object is a proc.
void rb_str_free(VALUE str)
Destroys the given string for no reason.
size_t rb_str_capacity(VALUE str)
Queries the capacity of the given string.
VALUE rb_mod_name(VALUE mod)
Queries the name of a module.
void rb_free_generic_ivar(VALUE obj)
Frees the list of instance variables.
void rb_undef_alloc_func(VALUE klass)
Deletes the allocator function of a class.
VALUE rb_check_funcall(VALUE recv, ID mid, int argc, const VALUE *argv)
Identical to rb_funcallv(), except it returns RUBY_Qundef instead of raising rb_eNoMethodError.
rb_alloc_func_t rb_get_alloc_func(VALUE klass)
Queries the allocator function of a class.
int rb_obj_respond_to(VALUE obj, ID mid, int private_p)
Identical to rb_respond_to(), except it additionally takes the visibility parameter.
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
int capa
Designed capacity of the buffer.
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
int rb_io_fptr_finalize(rb_io_t *fptr)
Destroys the given IO.
int len
Length of the buffer.
static bool rb_ractor_shareable_p(VALUE obj)
Queries if multiple Ractors can share the passed object or not.
#define RB_OBJ_SHAREABLE_P(obj)
Queries if the passed object has previously classified as shareable or not.
int ruby_thread_has_gvl_p(void)
Whether the current thread is holding the GVL.
void * rb_thread_call_with_gvl(void *(*func)(void *), void *data1)
(Re-)acquires the GVL.
bool ruby_free_at_exit_p(void)
Returns whether the Ruby VM will free all memory at shutdown.
VALUE rb_yield(VALUE val)
Yields the block.
#define RBIMPL_ATTR_MAYBE_UNUSED()
Wraps (or simulates) [[maybe_unused]].
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
#define RB_GC_GUARD(v)
Prevents premature destruction of local objects.
#define MEMMOVE(p1, p2, type, n)
Handy macro to call memmove.
VALUE type(ANYARGS)
ANYARGS-ed function type.
int st_foreach(st_table *q, int_type *w, st_data_t e)
Iteration over the given table.
#define RARRAY_LEN
Just another name of rb_array_len.
#define RARRAY(obj)
Convenient casting macro.
#define RARRAY_AREF(a, i)
References an object in an array.
#define RARRAY_CONST_PTR
Just another name of rb_array_const_ptr.
static VALUE RBASIC_CLASS(VALUE obj)
Queries the class of an object.
#define RBASIC(obj)
Convenient casting macro.
#define RCLASS(obj)
Convenient casting macro.
#define RUBY_DEFAULT_FREE
This is a value you can set to RData::dfree.
void(* RUBY_DATA_FUNC)(void *)
This is the type of callbacks registered to RData.
#define RUBY_NEVER_FREE
This is a value you can set to RData::dfree.
#define RFILE(obj)
Convenient casting macro.
#define RHASH_SIZE(h)
Queries the size of the hash.
#define RHASH_EMPTY_P(h)
Checks if the hash is empty.
#define RMATCH(obj)
Convenient casting macro.
#define ROBJECT(obj)
Convenient casting macro.
#define RREGEXP(obj)
Convenient casting macro.
static struct re_pattern_buffer * RREGEXP_PTR(VALUE rexp)
Convenient getter function.
static int RSTRING_LENINT(VALUE str)
Identical to RSTRING_LEN(), except it differs for the return type.
#define RSTRING(obj)
Convenient casting macro.
static rb_len_t RSTRUCT_LEN(VALUE st)
Returns the number of struct members.
#define RUBY_TYPED_DEFAULT_FREE
This is a value you can set to rb_data_type_struct::dfree.
VALUE rb_data_typed_object_wrap(VALUE klass, void *datap, const rb_data_type_t *type)
This is the primitive way to wrap an existing C struct into RTypedData.
VALUE rb_data_typed_object_zalloc(VALUE klass, size_t size, const rb_data_type_t *type)
Identical to rb_data_typed_object_wrap(), except it allocates a new data region internally instead of...
#define RUBY_TYPED_FREE_IMMEDIATELY
Macros to see if each corresponding flag is defined.
#define DATA_PTR(obj)
Convenient casting macro for backward compatibility.
static const rb_data_type_t * RTYPEDDATA_TYPE(VALUE obj)
Queries for the type of given object.
#define RDATA(obj)
Convenient casting macro for backward compatibility.
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
#define RTYPEDDATA(obj)
Convenient casting macro.
const char * rb_obj_classname(VALUE obj)
Queries the name of the class of the passed object.
void rb_p(VALUE obj)
Inspects an object.
#define errno
Ractor-aware version of errno.
int ruby_native_thread_p(void)
Queries if the thread which calls this function is a ruby's thread.
static bool RB_SPECIAL_CONST_P(VALUE obj)
Checks if the given object is of enum ruby_special_consts.
#define RTEST
This is an old name of RB_TEST.
#define _(args)
This was a transition path from K&R to ANSI.
Ruby object's base components.
Regular expression execution context.
struct rmatch_offset * char_offset
Capture group offsets, in C array.
union RMatch::@357327212031205367147161324375004050200256000107 as
"Registers" of a match.
int char_offset_num_allocated
Number of rmatch_offset that rmatch::char_offset holds.
int num_regs
Number of capture-group registers.
void * data
Pointer to the actual C level struct that you want to wrap.
VALUE fields_obj
Direct reference to the slots that holds instance variables, if any.
struct rb_data_type_struct::@006053276242002167166045007236206132153037024024 function
Function pointers.
RUBY_DATA_FUNC dcompact
This function is called when the object is relocated.
const char * wrap_struct_name
Name of structs of this kind.
RUBY_DATA_FUNC dmark
This function is called when the object is experiencing GC marks.
Ruby's IO, metadata and buffers.
const rb_iseq_t * iseqptr
iseq pointer, should be separated from iseqval
Represents the region of a capture group.
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.
long rb_len_t
A signed integer type for lengths and indices of objects such as String and Array.
intptr_t SIGNED_VALUE
A signed integer type that has the same width with VALUE.
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
ruby_value_type
C-level type of an object.
@ RUBY_T_MASK
Bitmask of ruby_value_type.