Ruby 3.5.0dev (2025-06-26 revision 7d01905ef1ca236ffd35ae160f6ecadce5129513)
class.h
1#ifndef INTERNAL_CLASS_H /*-*-C-*-vi:se ft=c:*/
2#define INTERNAL_CLASS_H
11#include "id.h"
12#include "id_table.h" /* for struct rb_id_table */
13#include "internal/namespace.h" /* for rb_current_namespace */
14#include "internal/serial.h" /* for rb_serial_t */
15#include "internal/static_assert.h"
16#include "internal/variable.h" /* for rb_class_ivar_set */
17#include "ruby/internal/stdbool.h" /* for bool */
18#include "ruby/intern.h" /* for rb_alloc_func_t */
19#include "ruby/ruby.h" /* for struct RBasic */
20#include "shape.h"
21#include "ruby_assert.h"
22#include "vm_core.h"
23#include "vm_sync.h"
24#include "method.h" /* for rb_cref_t */
25
26#ifdef RCLASS_SUPER
27# undef RCLASS_SUPER
28#endif
29
31 long refcount;
32 struct st_table *tbl;
33};
35
36static inline long
37rb_ns_subclasses_ref_count(rb_ns_subclasses_t *ns_sub)
38{
39 return ns_sub->refcount;
40}
41
42static inline rb_ns_subclasses_t *
43rb_ns_subclasses_ref_inc(rb_ns_subclasses_t *ns_sub)
44{
45 ns_sub->refcount++;
46 return ns_sub;
47}
48
49static inline void
50rb_ns_subclasses_ref_dec(rb_ns_subclasses_t *ns_sub)
51{
52 ns_sub->refcount--;
53 if (ns_sub->refcount == 0) {
54 st_free_table(ns_sub->tbl);
55 xfree(ns_sub);
56 }
57}
58
60 rb_ns_subclasses_t *ns_subclasses;
61 struct rb_subclass_entry *head;
62};
64
66 VALUE klass;
67 struct rb_subclass_entry *next;
68 struct rb_subclass_entry *prev;
69};
71
73 uint32_t index;
74 rb_serial_t global_cvar_state;
75 const rb_cref_t * cref;
76 VALUE class_value;
77};
78
80 const rb_namespace_t *ns;
81 VALUE super;
82 VALUE fields_obj; // Fields are either ivar or other internal properties stored inline
83 struct rb_id_table *m_tbl;
84 struct rb_id_table *const_tbl;
85 struct rb_id_table *callable_m_tbl;
86 struct rb_id_table *cc_tbl; /* ID -> [[ci1, cc1], [ci2, cc2] ...] */
87 struct rb_id_table *cvc_tbl;
88 VALUE *superclasses;
108
109 const VALUE origin_;
110 const VALUE refined_class;
111 union {
112 struct {
113 rb_alloc_func_t allocator;
114 } class;
115 struct {
116 VALUE attached_object;
117 } singleton_class;
118 struct {
119 const VALUE includer;
120 } iclass;
121 } as;
122 attr_index_t max_iv_count;
123 uint16_t superclass_depth;
124 unsigned char variation_count;
125 bool permanent_classpath : 1;
126 bool cloned : 1;
127 bool shared_const_tbl : 1;
128 bool iclass_is_origin : 1;
129 bool iclass_origin_shared_mtbl : 1;
130 bool superclasses_with_self : 1;
131 VALUE classpath;
132};
133typedef struct rb_classext_struct rb_classext_t;
134
135STATIC_ASSERT(shape_max_variations, SHAPE_MAX_VARIATIONS < (1 << (sizeof(((rb_classext_t *)0)->variation_count) * CHAR_BIT)));
136
137struct RClass {
138 struct RBasic basic;
139 VALUE object_id;
140 /*
141 * If ns_classext_tbl is NULL, then the prime classext is readable (because no other classext exists).
142 * For the check whether writable or not, check flag RCLASS_PRIME_CLASSEXT_WRITABLE
143 */
144};
145
147 struct RClass rclass;
148 rb_classext_t classext;
149};
150
151#if SIZEOF_VALUE >= SIZEOF_LONG_LONG
152// Assert that classes can be embedded in heaps[2] (which has 160B slot size)
153// On 32bit platforms there is no variable width allocation so it doesn't matter.
154STATIC_ASSERT(sizeof_rb_classext_t, sizeof(struct RClass_and_rb_classext_t) <= 4 * RVALUE_SIZE);
155#endif
156
158 struct RClass_and_rb_classext_t base;
159 st_table *ns_classext_tbl; // ns_object -> (rb_classext_t *)
160};
161
162static const uint16_t RCLASS_MAX_SUPERCLASS_DEPTH = ((uint16_t)-1);
163
164static inline bool RCLASS_SINGLETON_P(VALUE klass);
165
166static inline bool RCLASS_PRIME_CLASSEXT_READABLE_P(VALUE obj);
167static inline bool RCLASS_PRIME_CLASSEXT_WRITABLE_P(VALUE obj);
168static inline void RCLASS_SET_PRIME_CLASSEXT_WRITABLE(VALUE obj, bool writable);
169
170#define RCLASS_EXT_PRIME(c) (&((struct RClass_and_rb_classext_t*)(c))->classext)
171#define RCLASS_EXT_PRIME_P(ext, c) (&((struct RClass_and_rb_classext_t*)(c))->classext == ext)
172
173static inline rb_classext_t * RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns);
174static inline rb_classext_t * RCLASS_EXT_READABLE(VALUE obj);
175static inline rb_classext_t * RCLASS_EXT_WRITABLE_IN_NS(VALUE obj, const rb_namespace_t *ns);
176static inline rb_classext_t * RCLASS_EXT_WRITABLE(VALUE obj);
177
178// Raw accessor
179#define RCLASSEXT_NS(ext) (ext->ns)
180#define RCLASSEXT_SUPER(ext) (ext->super)
181#define RCLASSEXT_FIELDS(ext) (ext->fields_obj ? ROBJECT_FIELDS(ext->fields_obj) : NULL)
182#define RCLASSEXT_FIELDS_OBJ(ext) (ext->fields_obj)
183#define RCLASSEXT_M_TBL(ext) (ext->m_tbl)
184#define RCLASSEXT_CONST_TBL(ext) (ext->const_tbl)
185#define RCLASSEXT_CALLABLE_M_TBL(ext) (ext->callable_m_tbl)
186#define RCLASSEXT_CC_TBL(ext) (ext->cc_tbl)
187#define RCLASSEXT_CVC_TBL(ext) (ext->cvc_tbl)
188#define RCLASSEXT_SUPERCLASS_DEPTH(ext) (ext->superclass_depth)
189#define RCLASSEXT_SUPERCLASSES(ext) (ext->superclasses)
190#define RCLASSEXT_SUBCLASSES(ext) (ext->subclasses)
191#define RCLASSEXT_NS_SUPER_SUBCLASSES(ext) (ext->ns_super_subclasses)
192#define RCLASSEXT_NS_MODULE_SUBCLASSES(ext) (ext->ns_module_subclasses)
193#define RCLASSEXT_ORIGIN(ext) (ext->origin_)
194#define RCLASSEXT_REFINED_CLASS(ext) (ext->refined_class)
195// class.allocator/singleton_class.attached_object are not accessed directly via RCLASSEXT_*
196#define RCLASSEXT_INCLUDER(ext) (ext->as.iclass.includer)
197#define RCLASSEXT_PERMANENT_CLASSPATH(ext) (ext->permanent_classpath)
198#define RCLASSEXT_CLONED(ext) (ext->cloned)
199#define RCLASSEXT_SHARED_CONST_TBL(ext) (ext->shared_const_tbl)
200#define RCLASSEXT_ICLASS_IS_ORIGIN(ext) (ext->iclass_is_origin)
201#define RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext) (ext->iclass_origin_shared_mtbl)
202#define RCLASSEXT_SUPERCLASSES_WITH_SELF(ext) (ext->superclasses_with_self)
203#define RCLASSEXT_CLASSPATH(ext) (ext->classpath)
204
205static inline void RCLASSEXT_SET_ORIGIN(rb_classext_t *ext, VALUE klass, VALUE origin);
206static inline void RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE includer);
207
208/* Prime classext entry accessor for very specific reason */
209#define RCLASS_PRIME_NS(c) (RCLASS_EXT_PRIME(c)->ns)
210// To invalidate CC by inserting&invalidating method entry into tables containing the target cme
211// See clear_method_cache_by_id_in_class()
212#define RCLASS_PRIME_FIELDS_OBJ(c) (RCLASS_EXT_PRIME(c)->fields_obj)
213#define RCLASS_PRIME_M_TBL(c) (RCLASS_EXT_PRIME(c)->m_tbl)
214#define RCLASS_PRIME_CONST_TBL(c) (RCLASS_EXT_PRIME(c)->const_tbl)
215#define RCLASS_PRIME_CALLABLE_M_TBL(c) (RCLASS_EXT_PRIME(c)->callable_m_tbl)
216#define RCLASS_PRIME_CC_TBL(c) (RCLASS_EXT_PRIME(c)->cc_tbl)
217#define RCLASS_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->m_tbl != tbl)
218#define RCLASS_CALLABLE_M_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->callable_m_tbl != tbl)
219#define RCLASS_CC_TBL_NOT_PRIME_P(c, tbl) (RCLASS_EXT_PRIME(c)->cc_tbl != tbl)
220
221// Read accessor, regarding namespaces
222#define RCLASS_SUPER(c) (RCLASS_EXT_READABLE(c)->super)
223#define RCLASS_M_TBL(c) (RCLASS_EXT_READABLE(c)->m_tbl)
224#define RCLASS_CONST_TBL(c) (RCLASS_EXT_READABLE(c)->const_tbl)
225/*
226 * Both cc_tbl/callable_m_tbl are cache-like and always be changed when referreed,
227 * so always those should be writable.
228 */
229#define RCLASS_CVC_TBL(c) (RCLASS_EXT_READABLE(c)->cvc_tbl)
230#define RCLASS_SUBCLASSES_X(c) (RCLASS_EXT_READABLE(c)->subclasses)
231#define RCLASS_SUBCLASSES_FIRST(c) (RCLASS_EXT_READABLE(c)->subclasses->head->next)
232#define RCLASS_ORIGIN(c) (RCLASS_EXT_READABLE(c)->origin_)
233#define RICLASS_IS_ORIGIN_P(c) (RCLASS_EXT_READABLE(c)->iclass_is_origin)
234#define RCLASS_PERMANENT_CLASSPATH_P(c) (RCLASS_EXT_READABLE(c)->permanent_classpath)
235#define RCLASS_CLONED_P(c) (RCLASS_EXT_READABLE(c)->cloned)
236#define RCLASS_CLASSPATH(c) (RCLASS_EXT_READABLE(c)->classpath)
237
238// Superclasses can't be changed after initialization
239#define RCLASS_SUPERCLASS_DEPTH(c) (RCLASS_EXT_PRIME(c)->superclass_depth)
240#define RCLASS_SUPERCLASSES(c) (RCLASS_EXT_PRIME(c)->superclasses)
241#define RCLASS_SUPERCLASSES_WITH_SELF_P(c) (RCLASS_EXT_PRIME(c)->superclasses_with_self)
242
243// namespaces don't make changes on these refined_class/attached_object/includer
244#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT_PRIME(c)->refined_class)
245#define RCLASS_ATTACHED_OBJECT(c) (RCLASS_EXT_PRIME(c)->as.singleton_class.attached_object)
246#define RCLASS_INCLUDER(c) (RCLASS_EXT_PRIME(c)->as.iclass.includer)
247
248// max IV count and variation count are just hints, so they don't need to be per-namespace
249#define RCLASS_MAX_IV_COUNT(ext) (RCLASS_EXT_PRIME(ext)->max_iv_count)
250#define RCLASS_VARIATION_COUNT(ext) (RCLASS_EXT_PRIME(ext)->variation_count)
251
252// Writable classext entries (instead of RCLASS_SET_*) because member data will be operated directly
253#define RCLASS_WRITABLE_M_TBL(c) (RCLASS_EXT_WRITABLE(c)->m_tbl)
254#define RCLASS_WRITABLE_CONST_TBL(c) (RCLASS_EXT_WRITABLE(c)->const_tbl)
255#define RCLASS_WRITABLE_CALLABLE_M_TBL(c) (RCLASS_EXT_WRITABLE(c)->callable_m_tbl)
256#define RCLASS_WRITABLE_CC_TBL(c) (RCLASS_EXT_WRITABLE(c)->cc_tbl)
257#define RCLASS_WRITABLE_CVC_TBL(c) (RCLASS_EXT_WRITABLE(c)->cvc_tbl)
258#define RCLASS_WRITABLE_SUBCLASSES(c) (RCLASS_EXT_WRITABLE(c)->subclasses)
259
260static inline void RCLASS_SET_SUPER(VALUE klass, VALUE super);
261static inline void RCLASS_WRITE_SUPER(VALUE klass, VALUE super);
262// TODO: rename RCLASS_SET_M_TBL_WORKAROUND (and _WRITE_) to RCLASS_SET_M_TBL with write barrier
263static inline void RCLASS_SET_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check_promoted);
264static inline void RCLASS_WRITE_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check_promoted);
265static inline void RCLASS_SET_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared);
266static inline void RCLASS_WRITE_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared);
267static inline void RCLASS_WRITE_CALLABLE_M_TBL(VALUE klass, struct rb_id_table *table);
268static inline void RCLASS_WRITE_CC_TBL(VALUE klass, struct rb_id_table *table);
269static inline void RCLASS_SET_CVC_TBL(VALUE klass, struct rb_id_table *table);
270static inline void RCLASS_WRITE_CVC_TBL(VALUE klass, struct rb_id_table *table);
271
272static inline void RCLASS_WRITE_SUPERCLASSES(VALUE klass, size_t depth, VALUE *superclasses, bool with_self);
273static inline void RCLASS_SET_SUBCLASSES(VALUE klass, rb_subclass_anchor_t *anchor);
274static inline void RCLASS_WRITE_NS_SUPER_SUBCLASSES(VALUE klass, rb_ns_subclasses_t *ns_subclasses);
275static inline void RCLASS_WRITE_NS_MODULE_SUBCLASSES(VALUE klass, rb_ns_subclasses_t *ns_subclasses);
276
277static inline void RCLASS_SET_ORIGIN(VALUE klass, VALUE origin);
278static inline void RCLASS_WRITE_ORIGIN(VALUE klass, VALUE origin);
279static inline void RICLASS_SET_ORIGIN_SHARED_MTBL(VALUE iclass);
280static inline void RICLASS_WRITE_ORIGIN_SHARED_MTBL(VALUE iclass);
281static inline bool RICLASS_OWNS_M_TBL_P(VALUE iclass);
282
283static inline void RCLASS_SET_REFINED_CLASS(VALUE klass, VALUE refined);
284static inline rb_alloc_func_t RCLASS_ALLOCATOR(VALUE klass);
285static inline void RCLASS_SET_ALLOCATOR(VALUE klass, rb_alloc_func_t allocator);
286static inline VALUE RCLASS_SET_ATTACHED_OBJECT(VALUE klass, VALUE attached_object);
287
288static inline void RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass);
289static inline void RCLASS_SET_MAX_IV_COUNT(VALUE klass, attr_index_t count);
290static inline void RCLASS_SET_CLONED(VALUE klass, bool cloned);
291static inline void RCLASS_SET_CLASSPATH(VALUE klass, VALUE classpath, bool permanent);
292static inline void RCLASS_WRITE_CLASSPATH(VALUE klass, VALUE classpath, bool permanent);
293
294#define RCLASS_IS_ROOT FL_USER0
295// 1 is for RUBY_FL_SINGLETON or RMODULE_IS_REFINEMENT
296#define RCLASS_PRIME_CLASSEXT_WRITABLE FL_USER2
297#define RCLASS_IS_INITIALIZED FL_USER3
298// 3 is RMODULE_IS_REFINEMENT for RMODULE
299#define RCLASS_NAMESPACEABLE FL_USER4
300
301static inline st_table *
302RCLASS_CLASSEXT_TBL(VALUE klass)
303{
304 if (FL_TEST_RAW(klass, RCLASS_NAMESPACEABLE)) {
305 struct RClass_namespaceable *ns_klass = (struct RClass_namespaceable *)klass;
306 return ns_klass->ns_classext_tbl;
307 }
308 return NULL;
309}
310
311static inline void
312RCLASS_SET_CLASSEXT_TBL(VALUE klass, st_table *tbl)
313{
314 RUBY_ASSERT(FL_TEST_RAW(klass, RCLASS_NAMESPACEABLE));
315 struct RClass_namespaceable *ns_klass = (struct RClass_namespaceable *)klass;
316 ns_klass->ns_classext_tbl = tbl;
317}
318
319/* class.c */
320rb_classext_t * rb_class_duplicate_classext(rb_classext_t *orig, VALUE obj, const rb_namespace_t *ns);
321void rb_class_ensure_writable(VALUE obj);
322
323static inline int
324RCLASS_SET_NAMESPACE_CLASSEXT(VALUE obj, const rb_namespace_t *ns, rb_classext_t *ext)
325{
326 int first_set = 0;
327 st_table *tbl = RCLASS_CLASSEXT_TBL(obj);
328 VM_ASSERT(NAMESPACE_USER_P(ns)); // non-prime classext is only for user namespace, with ns_object
329 VM_ASSERT(ns->ns_object);
330 VM_ASSERT(RCLASSEXT_NS(ext) == ns);
331 if (!tbl) {
332 tbl = st_init_numtable_with_size(1);
333 RCLASS_SET_CLASSEXT_TBL(obj, tbl);
334 }
335 if (rb_st_table_size(tbl) == 0) {
336 first_set = 1;
337 }
338 rb_st_insert(tbl, (st_data_t)ns->ns_object, (st_data_t)ext);
339 return first_set;
340}
341
342static inline bool
343RCLASS_PRIME_CLASSEXT_READABLE_P(VALUE klass)
344{
345 VM_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_MODULE) || RB_TYPE_P(klass, T_ICLASS));
346 // if the lookup table exists, then it means the prime classext is NOT directly readable.
347 return !FL_TEST_RAW(klass, RCLASS_NAMESPACEABLE) || RCLASS_CLASSEXT_TBL(klass) == NULL;
348}
349
350static inline bool
351RCLASS_PRIME_CLASSEXT_WRITABLE_P(VALUE klass)
352{
353 VM_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_MODULE) || RB_TYPE_P(klass, T_ICLASS));
354 return FL_TEST(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
355}
356
357static inline void
358RCLASS_SET_PRIME_CLASSEXT_WRITABLE(VALUE klass, bool writable)
359{
360 VM_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_MODULE) || RB_TYPE_P(klass, T_ICLASS));
361
362 if (writable) {
363 FL_SET(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
364 }
365 else {
366 FL_UNSET(klass, RCLASS_PRIME_CLASSEXT_WRITABLE);
367 }
368}
369
370static inline rb_classext_t *
371RCLASS_EXT_TABLE_LOOKUP_INTERNAL(VALUE obj, const rb_namespace_t *ns)
372{
373 st_data_t classext_ptr;
374 st_table *classext_tbl = RCLASS_CLASSEXT_TBL(obj);
375 if (classext_tbl) {
376 if (rb_st_lookup(classext_tbl, (st_data_t)ns->ns_object, &classext_ptr)) {
377 return (rb_classext_t *)classext_ptr;
378 }
379 }
380 return NULL;
381}
382
383static inline rb_classext_t *
384RCLASS_EXT_READABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)
385{
386 rb_classext_t *ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);
387 if (ext)
388 return ext;
389 // Classext for the ns not found. Refer the prime one instead.
390 return RCLASS_EXT_PRIME(obj);
391}
392
393static inline rb_classext_t *
394RCLASS_EXT_READABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)
395{
396 if (!ns
397 || NAMESPACE_BUILTIN_P(ns)
398 || RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
399 return RCLASS_EXT_PRIME(obj);
400 }
401 return RCLASS_EXT_READABLE_LOOKUP(obj, ns);
402}
403
404static inline rb_classext_t *
405RCLASS_EXT_READABLE(VALUE obj)
406{
407 const rb_namespace_t *ns;
408 if (RCLASS_PRIME_CLASSEXT_READABLE_P(obj)) {
409 return RCLASS_EXT_PRIME(obj);
410 }
411 // delay namespace loading to optimize for unmodified classes
412 ns = rb_current_namespace();
413 if (!ns || NAMESPACE_BUILTIN_P(ns)) {
414 return RCLASS_EXT_PRIME(obj);
415 }
416 return RCLASS_EXT_READABLE_LOOKUP(obj, ns);
417}
418
419static inline rb_classext_t *
420RCLASS_EXT_WRITABLE_LOOKUP(VALUE obj, const rb_namespace_t *ns)
421{
422 rb_classext_t *ext;
423 int first_set = 0;
424
425 ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);
426 if (ext)
427 return ext;
428
429 RB_VM_LOCKING() {
430 // re-check the classext is not created to avoid the multi-thread race
431 ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);
432 if (!ext) {
433 ext = rb_class_duplicate_classext(RCLASS_EXT_PRIME(obj), obj, ns);
434 first_set = RCLASS_SET_NAMESPACE_CLASSEXT(obj, ns, ext);
435 if (first_set) {
436 RCLASS_SET_PRIME_CLASSEXT_WRITABLE(obj, false);
437 }
438 }
439 }
440 return ext;
441}
442
443static inline rb_classext_t *
444RCLASS_EXT_WRITABLE_IN_NS(VALUE obj, const rb_namespace_t *ns)
445{
446 if (!ns
447 || NAMESPACE_BUILTIN_P(ns)
448 || RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj)) {
449 return RCLASS_EXT_PRIME(obj);
450 }
451 return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);
452}
453
454static inline rb_classext_t *
455RCLASS_EXT_WRITABLE(VALUE obj)
456{
457 const rb_namespace_t *ns;
458 if (LIKELY(RCLASS_PRIME_CLASSEXT_WRITABLE_P(obj))) {
459 return RCLASS_EXT_PRIME(obj);
460 }
461 // delay namespace loading to optimize for unmodified classes
462 ns = rb_current_namespace();
463 if (!ns || NAMESPACE_BUILTIN_P(ns)) {
464 // If no namespace is specified, Ruby VM is in bootstrap
465 // and the clean class definition is under construction.
466 return RCLASS_EXT_PRIME(obj);
467 }
468 return RCLASS_EXT_WRITABLE_LOOKUP(obj, ns);
469}
470
471static inline void
472RCLASSEXT_SET_ORIGIN(rb_classext_t *ext, VALUE klass, VALUE origin)
473{
474 RB_OBJ_WRITE(klass, &(RCLASSEXT_ORIGIN(ext)), origin);
475}
476
477static inline void
478RCLASSEXT_SET_INCLUDER(rb_classext_t *ext, VALUE klass, VALUE includer)
479{
481 RB_OBJ_WRITE(klass, &(RCLASSEXT_INCLUDER(ext)), includer);
482}
483
484/* class.c */
485typedef void rb_class_classext_foreach_callback_func(rb_classext_t *classext, bool is_prime, VALUE namespace, void *arg);
486void rb_class_classext_foreach(VALUE klass, rb_class_classext_foreach_callback_func *func, void *arg);
487void rb_class_subclass_add(VALUE super, VALUE klass);
488void rb_class_remove_from_super_subclasses(VALUE);
489void rb_class_remove_from_module_subclasses(VALUE);
490void rb_class_classext_free_subclasses(rb_classext_t *, VALUE);
491void rb_class_foreach_subclass(VALUE klass, void (*f)(VALUE, VALUE), VALUE);
492void rb_class_detach_subclasses(VALUE);
493void rb_class_detach_module_subclasses(VALUE);
494void rb_class_update_superclasses(VALUE);
495size_t rb_class_superclasses_memsize(VALUE);
496void rb_class_remove_subclass_head(VALUE);
497int rb_singleton_class_internal_p(VALUE sklass);
498VALUE rb_class_set_super(VALUE klass, VALUE super);
500VALUE rb_class_s_alloc(VALUE klass);
501VALUE rb_module_s_alloc(VALUE klass);
502void rb_class_set_initialized(VALUE klass);
503void rb_module_check_initializable(VALUE module);
504VALUE rb_make_metaclass(VALUE, VALUE);
505VALUE rb_include_class_new(VALUE, VALUE);
506VALUE rb_define_class_id_under_no_pin(VALUE outer, ID id, VALUE super);
507VALUE rb_obj_methods(int argc, const VALUE *argv, VALUE obj);
508VALUE rb_obj_protected_methods(int argc, const VALUE *argv, VALUE obj);
509VALUE rb_obj_private_methods(int argc, const VALUE *argv, VALUE obj);
510VALUE rb_obj_public_methods(int argc, const VALUE *argv, VALUE obj);
511VALUE rb_class_undefined_instance_methods(VALUE mod);
512VALUE rb_special_singleton_class(VALUE);
513VALUE rb_singleton_class_clone_and_attach(VALUE obj, VALUE attach);
515void rb_undef_methods_from(VALUE klass, VALUE super);
517VALUE rb_keyword_error_new(const char *, VALUE);
518
519RUBY_SYMBOL_EXPORT_BEGIN
520
521/* for objspace */
522VALUE rb_class_super_of(VALUE klass);
523VALUE rb_class_singleton_p(VALUE klass);
524unsigned char rb_class_variation_count(VALUE klass);
525
526RUBY_SYMBOL_EXPORT_END
527
528static inline bool
529RCLASS_SINGLETON_P(VALUE klass)
530{
531 return RB_TYPE_P(klass, T_CLASS) && FL_TEST_RAW(klass, FL_SINGLETON);
532}
533
534static inline void
535RCLASS_SET_SUPER(VALUE klass, VALUE super)
536{
537 RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT_PRIME(klass)), super);
538}
539
540static inline void
541RCLASS_WRITE_SUPER(VALUE klass, VALUE super)
542{
543 RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT_WRITABLE(klass)), super);
544}
545
546static inline VALUE
547RCLASS_WRITABLE_ENSURE_FIELDS_OBJ(VALUE obj)
548{
550 rb_classext_t *ext = RCLASS_EXT_WRITABLE(obj);
551 if (!ext->fields_obj) {
552 RB_OBJ_WRITE(obj, &ext->fields_obj, rb_imemo_fields_new(rb_singleton_class(obj), 1));
553 }
554 return ext->fields_obj;
555}
556
557static inline VALUE
558RCLASS_WRITABLE_FIELDS_OBJ(VALUE obj)
559{
561 return RCLASSEXT_FIELDS_OBJ(RCLASS_EXT_WRITABLE(obj));
562}
563
564static inline void
565RCLASSEXT_SET_FIELDS_OBJ(VALUE obj, rb_classext_t *ext, VALUE fields_obj)
566{
568
569 VALUE old_fields_obj = ext->fields_obj;
570 RUBY_ATOMIC_VALUE_SET(ext->fields_obj, fields_obj);
571 RB_OBJ_WRITTEN(obj, old_fields_obj, fields_obj);
572}
573
574static inline void
575RCLASS_WRITABLE_SET_FIELDS_OBJ(VALUE obj, VALUE fields_obj)
576{
578
579 RCLASSEXT_SET_FIELDS_OBJ(obj, RCLASS_EXT_WRITABLE(obj), fields_obj);
580}
581
582static inline uint32_t
583RCLASS_FIELDS_COUNT(VALUE obj)
584{
586
587 VALUE fields_obj = RCLASS_WRITABLE_FIELDS_OBJ(obj);
588 if (fields_obj) {
589 if (rb_shape_obj_too_complex_p(fields_obj)) {
590 return (uint32_t)rb_st_table_size(rb_imemo_fields_complex_tbl(fields_obj));
591 }
592 else {
593 return RSHAPE_LEN(RBASIC_SHAPE_ID(fields_obj));
594 }
595 }
596 return 0;
597}
598
599#define RCLASS_SET_M_TBL_EVEN_WHEN_PROMOTED(klass, table) RCLASS_SET_M_TBL_WORKAROUND(klass, table, false)
600#define RCLASS_SET_M_TBL(klass, table) RCLASS_SET_M_TBL_WORKAROUND(klass, table, true)
601
602static inline void
603RCLASS_SET_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check_promoted)
604{
605 RUBY_ASSERT(!check_promoted || !RB_OBJ_PROMOTED(klass));
606 RCLASSEXT_M_TBL(RCLASS_EXT_PRIME(klass)) = table;
607}
608
609#define RCLASS_WRITE_M_TBL_EVEN_WHEN_PROMOTED(klass, table) RCLASS_WRITE_M_TBL_WORKAROUND(klass, table, false)
610#define RCLASS_WRITE_M_TBL(klass, table) RCLASS_WRITE_M_TBL_WORKAROUND(klass, table, true)
611
612static inline void
613RCLASS_WRITE_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check_promoted)
614{
615 RUBY_ASSERT(!check_promoted || !RB_OBJ_PROMOTED(klass));
616 // TODO: add write barrier here to guard assigning m_tbl
617 // see commit 28a6e4ea9d9379a654a8f7c4b37fa33aa3ccd0b7
618 RCLASSEXT_M_TBL(RCLASS_EXT_WRITABLE(klass)) = table;
619}
620
621static inline void
622RCLASS_SET_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared)
623{
624 rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
625 RCLASSEXT_CONST_TBL(ext) = table;
626 if (shared)
627 RCLASSEXT_SHARED_CONST_TBL(ext) = true;
628}
629
630static inline void
631RCLASS_WRITE_CONST_TBL(VALUE klass, struct rb_id_table *table, bool shared)
632{
633 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
634 RCLASSEXT_CONST_TBL(ext) = table;
635 if (shared)
636 RCLASSEXT_SHARED_CONST_TBL(ext) = true;
637}
638
639static inline void
640RCLASS_WRITE_CALLABLE_M_TBL(VALUE klass, struct rb_id_table *table)
641{
642 RCLASSEXT_CALLABLE_M_TBL(RCLASS_EXT_WRITABLE(klass)) = table;
643}
644
645static inline void
646RCLASS_WRITE_CC_TBL(VALUE klass, struct rb_id_table *table)
647{
648 RCLASSEXT_CC_TBL(RCLASS_EXT_WRITABLE(klass)) = table;
649}
650
651static inline void
652RCLASS_SET_CVC_TBL(VALUE klass, struct rb_id_table *table)
653{
654 RCLASSEXT_CVC_TBL(RCLASS_EXT_PRIME(klass)) = table;
655}
656
657static inline void
658RCLASS_WRITE_CVC_TBL(VALUE klass, struct rb_id_table *table)
659{
660 RCLASSEXT_CVC_TBL(RCLASS_EXT_WRITABLE(klass)) = table;
661}
662
663static inline void
664RCLASS_SET_REFINED_CLASS(VALUE klass, VALUE refined)
665{
666 RB_OBJ_WRITE(klass, &RCLASSEXT_REFINED_CLASS(RCLASS_EXT_PRIME(klass)), refined);
667}
668
669static inline rb_alloc_func_t
670RCLASS_ALLOCATOR(VALUE klass)
671{
672 RUBY_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_ICLASS));
673 if (RCLASS_SINGLETON_P(klass) || RB_TYPE_P(klass, T_ICLASS)) {
674 return 0;
675 }
676 return RCLASS_EXT_PRIME(klass)->as.class.allocator;
677}
678
679static inline void
680RCLASS_SET_ALLOCATOR(VALUE klass, rb_alloc_func_t allocator)
681{
683 RUBY_ASSERT(!RCLASS_SINGLETON_P(klass));
684 RCLASS_EXT_PRIME(klass)->as.class.allocator = allocator; // Allocator is set only on the initial definition
685}
686
687static inline void
688RCLASS_SET_ORIGIN(VALUE klass, VALUE origin)
689{
690 rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
691 RB_OBJ_WRITE(klass, &RCLASSEXT_ORIGIN(ext), origin);
692 if (klass != origin) RCLASSEXT_ICLASS_IS_ORIGIN(RCLASS_EXT_WRITABLE(origin)) = true;
693}
694
695static inline void
696RCLASS_WRITE_ORIGIN(VALUE klass, VALUE origin)
697{
698 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
699 RB_OBJ_WRITE(klass, &RCLASSEXT_ORIGIN(ext), origin);
700 if (klass != origin) RCLASSEXT_ICLASS_IS_ORIGIN(RCLASS_EXT_WRITABLE(origin)) = true;
701}
702
703static inline void
704RICLASS_SET_ORIGIN_SHARED_MTBL(VALUE iclass)
705{
706 RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(RCLASS_EXT_PRIME(iclass)) = true;
707}
708
709static inline void
710RICLASS_WRITE_ORIGIN_SHARED_MTBL(VALUE iclass)
711{
712 RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(RCLASS_EXT_WRITABLE(iclass)) = true;
713}
714
715static inline bool
716RICLASS_OWNS_M_TBL_P(VALUE iclass)
717{
718 rb_classext_t *ext = RCLASS_EXT_READABLE(iclass);
719 return RCLASSEXT_ICLASS_IS_ORIGIN(ext) && !RCLASSEXT_ICLASS_ORIGIN_SHARED_MTBL(ext);
720}
721
722static inline void
723RCLASS_SET_INCLUDER(VALUE iclass, VALUE klass)
724{
726 RB_OBJ_WRITE(iclass, &RCLASS_INCLUDER(iclass), klass);
727}
728
729static inline void
730RCLASS_WRITE_SUPERCLASSES(VALUE klass, size_t depth, VALUE *superclasses, bool with_self)
731{
732 RUBY_ASSERT(depth <= RCLASS_MAX_SUPERCLASS_DEPTH);
733
734 rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
735 RCLASSEXT_SUPERCLASS_DEPTH(ext) = depth;
736 RCLASSEXT_SUPERCLASSES(ext) = superclasses;
737 RCLASSEXT_SUPERCLASSES_WITH_SELF(ext) = with_self;
738}
739
740static inline void
741RCLASS_SET_SUBCLASSES(VALUE klass, struct rb_subclass_anchor *anchor)
742{
743 rb_classext_t *ext = RCLASS_EXT_PRIME(klass);
744 RCLASSEXT_SUBCLASSES(ext) = anchor;
745}
746
747static inline void
748RCLASS_WRITE_NS_SUPER_SUBCLASSES(VALUE klass, rb_ns_subclasses_t *ns_subclasses)
749{
750 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
751 if (RCLASSEXT_NS_SUPER_SUBCLASSES(ext))
752 rb_ns_subclasses_ref_dec(RCLASSEXT_NS_SUPER_SUBCLASSES(ext));
753 RCLASSEXT_NS_SUPER_SUBCLASSES(ext) = rb_ns_subclasses_ref_inc(ns_subclasses);
754}
755
756static inline void
757RCLASS_WRITE_NS_MODULE_SUBCLASSES(VALUE klass, rb_ns_subclasses_t *ns_subclasses)
758{
759 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
760 if (RCLASSEXT_NS_MODULE_SUBCLASSES(ext))
761 rb_ns_subclasses_ref_dec(RCLASSEXT_NS_MODULE_SUBCLASSES(ext));
762 RCLASSEXT_NS_MODULE_SUBCLASSES(ext) = rb_ns_subclasses_ref_inc(ns_subclasses);
763}
764
765static inline void
766RCLASS_SET_CLASSPATH(VALUE klass, VALUE classpath, bool permanent)
767{
768 rb_classext_t *ext = RCLASS_EXT_READABLE(klass);
769 assert(BUILTIN_TYPE(klass) == T_CLASS || BUILTIN_TYPE(klass) == T_MODULE);
770 assert(classpath == 0 || BUILTIN_TYPE(classpath) == T_STRING);
771
772 RB_OBJ_WRITE(klass, &(RCLASSEXT_CLASSPATH(ext)), classpath);
773 RCLASSEXT_PERMANENT_CLASSPATH(ext) = permanent;
774}
775
776static inline void
777RCLASS_WRITE_CLASSPATH(VALUE klass, VALUE classpath, bool permanent)
778{
779 rb_classext_t *ext = RCLASS_EXT_WRITABLE(klass);
780 assert(BUILTIN_TYPE(klass) == T_CLASS || BUILTIN_TYPE(klass) == T_MODULE);
781 assert(classpath == 0 || BUILTIN_TYPE(classpath) == T_STRING);
782
783 RB_OBJ_WRITE(klass, &(RCLASSEXT_CLASSPATH(ext)), classpath);
784 RCLASSEXT_PERMANENT_CLASSPATH(ext) = permanent;
785}
786
787static inline VALUE
788RCLASS_SET_ATTACHED_OBJECT(VALUE klass, VALUE attached_object)
789{
790 assert(RCLASS_SINGLETON_P(klass));
791
792 RB_OBJ_WRITE(klass, &RCLASS_EXT_PRIME(klass)->as.singleton_class.attached_object, attached_object);
793 return attached_object;
794}
795
796static inline void
797RCLASS_SET_MAX_IV_COUNT(VALUE klass, attr_index_t count)
798{
799 RCLASS_MAX_IV_COUNT(klass) = count;
800}
801
802static inline void
803RCLASS_SET_CLONED(VALUE klass, bool cloned)
804{
805 RCLASSEXT_CLONED(RCLASS_EXT_PRIME(klass)) = cloned;
806}
807
808static inline bool
809RCLASS_INITIALIZED_P(VALUE klass)
810{
811 VM_ASSERT(RB_TYPE_P(klass, T_CLASS) || RB_TYPE_P(klass, T_MODULE));
812 return FL_TEST_RAW(klass, RCLASS_IS_INITIALIZED);
813}
814
815#endif /* INTERNAL_CLASS_H */
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
#define RUBY_ATOMIC_VALUE_SET(var, val)
Identical to RUBY_ATOMIC_SET, except it expects its arguments are VALUE.
Definition atomic.h:353
VALUE rb_singleton_class(VALUE obj)
Finds or creates the singleton class of the passed object.
Definition class.c:2800
VALUE rb_class_boot(VALUE)
A utility function that wraps class_alloc.
Definition class.c:773
VALUE rb_class_inherited(VALUE, VALUE)
Calls Class::inherited.
Definition class.c:1475
VALUE rb_singleton_class_get(VALUE obj)
Returns the singleton class of obj, or nil if obj is not a singleton object.
Definition class.c:2786
#define FL_SINGLETON
Old name of RUBY_FL_SINGLETON.
Definition fl_type.h:58
#define T_STRING
Old name of RUBY_T_STRING.
Definition value_type.h:78
#define xfree
Old name of ruby_xfree.
Definition xmalloc.h:58
#define T_MODULE
Old name of RUBY_T_MODULE.
Definition value_type.h:70
#define T_ICLASS
Old name of RUBY_T_ICLASS.
Definition value_type.h:66
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
Definition fl_type.h:131
#define FL_SET
Old name of RB_FL_SET.
Definition fl_type.h:128
#define T_CLASS
Old name of RUBY_T_CLASS.
Definition value_type.h:58
#define BUILTIN_TYPE
Old name of RB_BUILTIN_TYPE.
Definition value_type.h:85
#define FL_TEST
Old name of RB_FL_TEST.
Definition fl_type.h:130
#define FL_UNSET
Old name of RB_FL_UNSET.
Definition fl_type.h:132
#define RB_OBJ_WRITTEN(old, oldv, young)
Identical to RB_OBJ_WRITE(), except it doesn't write any values, but only a WB declaration.
Definition gc.h:615
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
Definition gc.h:603
static bool RB_OBJ_PROMOTED(VALUE obj)
Tests if the object is "promoted" – that is, whether the object experienced one or more GC marks.
Definition gc.h:726
VALUE(* rb_alloc_func_t)(VALUE klass)
This is the type of functions that ruby calls when trying to allocate an object.
Definition vm.h:216
C99 shim for <stdbool.h>
Ruby object's base components.
Definition rbasic.h:69
struct rb_subclass_anchor * subclasses
The head of subclasses is a blank (w/o klass) entry to be referred from anchor (and be never deleted)...
Definition class.h:93
rb_ns_subclasses_t * ns_module_subclasses
In the case that this is an ICLASS, ns_module_subclasses points to the link in the module's subclasse...
Definition class.h:107
rb_ns_subclasses_t * ns_super_subclasses
The ns_super_subclasses points the ns_subclasses struct to retreive the subclasses of the super class...
Definition class.h:101
CREF (Class REFerence)
Definition method.h:45
Definition class.h:72
Internal header for Namespace.
Definition namespace.h:14
Internal header for Class.
Definition class.h:30
Definition class.h:65
Definition st.h:79
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.
Definition value_type.h:376
@ RUBY_T_MODULE
Definition value_type.h:118
@ RUBY_T_CLASS
Definition value_type.h:117