Ruby 3.5.0dev (2025-08-02 revision 30a20bc166bc37acd7dcb3788686df149c7f428a)
imemo.h
1#ifndef INTERNAL_IMEMO_H /*-*-C-*-vi:se ft=c:*/
2#define INTERNAL_IMEMO_H
11#include "ruby/internal/config.h"
12#include <stddef.h> /* for size_t */
13#include "id_table.h"
14#include "internal/array.h" /* for rb_ary_hidden_new_fill */
15#include "ruby/internal/stdbool.h" /* for bool */
16#include "ruby/ruby.h" /* for rb_block_call_func_t */
17
18#define IMEMO_MASK 0x0f
19
20/* FL_USER0 to FL_USER3 is for type */
21#define IMEMO_FL_USHIFT (FL_USHIFT + 4)
22#define IMEMO_FL_USER0 FL_USER4
23#define IMEMO_FL_USER1 FL_USER5
24#define IMEMO_FL_USER2 FL_USER6
25#define IMEMO_FL_USER3 FL_USER7
26#define IMEMO_FL_USER4 FL_USER8
27#define IMEMO_FL_USER5 FL_USER9
28#define IMEMO_FL_USER6 FL_USER10
29
30enum imemo_type {
31 imemo_env = 0,
32 imemo_cref = 1,
33 imemo_svar = 2,
34 imemo_throw_data = 3,
35 imemo_ifunc = 4,
36 imemo_memo = 5,
37 imemo_ment = 6,
38 imemo_iseq = 7,
39 imemo_tmpbuf = 8,
40 imemo_callinfo = 10,
41 imemo_callcache = 11,
42 imemo_constcache = 12,
43 imemo_fields = 13,
44};
45
46/* CREF (Class REFerence) is defined in method.h */
47
49struct vm_svar {
50 VALUE flags;
52 const VALUE lastline;
53 const VALUE backref;
54 const VALUE others;
55};
56
59 VALUE flags;
60 VALUE reserved;
61 const VALUE throw_obj;
62 const struct rb_control_frame_struct *catch_frame;
63 int throw_state;
64};
65
66#define THROW_DATA_CONSUMED IMEMO_FL_USER0
67
68/* IFUNC (Internal FUNCtion) */
69
71#if SIZEOF_INT * 2 > SIZEOF_VALUE
72 signed int min: (SIZEOF_VALUE * CHAR_BIT) / 2;
73 signed int max: (SIZEOF_VALUE * CHAR_BIT) / 2;
74#else
75 int min, max;
76#endif
77};
78
85struct vm_ifunc {
86 VALUE flags;
87 VALUE *svar_lep;
89 const void *data;
90 struct vm_ifunc_argc argc;
91};
92#define IFUNC_YIELD_OPTIMIZABLE IMEMO_FL_USER0
93
95 VALUE flags;
96 VALUE reserved;
97 VALUE *ptr; /* malloc'ed buffer */
98 struct rb_imemo_tmpbuf_struct *next; /* next imemo */
99 size_t cnt; /* buffer size in VALUE */
100};
101
106struct MEMO {
107 VALUE flags;
108 VALUE reserved;
109 const VALUE v1;
110 const VALUE v2;
111 union {
112 long cnt;
113 long state;
114 const VALUE value;
115 void (*func)(void);
116 } u3;
117};
118
119#define IMEMO_NEW(T, type, v0) ((T *)rb_imemo_new((type), (v0), sizeof(T)))
120
121/* ment is in method.h */
122
123#define THROW_DATA_P(err) imemo_throw_data_p((VALUE)err)
124#define MEMO_CAST(m) ((struct MEMO *)(m))
125#define MEMO_FOR(type, value) ((type *)RARRAY_PTR(value))
126#define NEW_MEMO_FOR(type, value) \
127 ((value) = rb_ary_hidden_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
128#define NEW_PARTIAL_MEMO_FOR(type, value, member) \
129 ((value) = rb_ary_hidden_new_fill(type_roomof(type, VALUE)), \
130 rb_ary_set_len((value), offsetof(type, member) / sizeof(VALUE)), \
131 MEMO_FOR(type, value))
132
133#ifndef RUBY_RUBYPARSER_H
135#endif
136rb_imemo_tmpbuf_t *rb_imemo_tmpbuf_parser_heap(void *buf, rb_imemo_tmpbuf_t *old_heap, size_t cnt);
137struct vm_ifunc *rb_vm_ifunc_new(rb_block_call_func_t func, const void *data, int min_argc, int max_argc);
138static inline enum imemo_type imemo_type(VALUE imemo);
139static inline int imemo_type_p(VALUE imemo, enum imemo_type imemo_type);
140static inline bool imemo_throw_data_p(VALUE imemo);
141static inline struct vm_ifunc *rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data);
142static inline VALUE rb_imemo_tmpbuf_auto_free_pointer(void);
143static inline void *RB_IMEMO_TMPBUF_PTR(VALUE v);
144static inline void *rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr);
145static inline VALUE rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str);
146static inline void MEMO_V1_SET(struct MEMO *m, VALUE v);
147static inline void MEMO_V2_SET(struct MEMO *m, VALUE v);
148
149size_t rb_imemo_memsize(VALUE obj);
150void rb_imemo_mark_and_move(VALUE obj, bool reference_updating);
151void rb_imemo_free(VALUE obj);
152
153RUBY_SYMBOL_EXPORT_BEGIN
154VALUE rb_imemo_new(enum imemo_type type, VALUE v0, size_t size);
155const char *rb_imemo_name(enum imemo_type type);
156RUBY_SYMBOL_EXPORT_END
157
158static inline struct MEMO *
159MEMO_NEW(VALUE a, VALUE b, VALUE c)
160{
161 struct MEMO *memo = IMEMO_NEW(struct MEMO, imemo_memo, 0);
162 *((VALUE *)&memo->v1) = a;
163 *((VALUE *)&memo->v2) = b;
164 *((VALUE *)&memo->u3.value) = c;
165
166 return memo;
167}
168
169static inline enum imemo_type
170imemo_type(VALUE imemo)
171{
172 return (RBASIC(imemo)->flags >> FL_USHIFT) & IMEMO_MASK;
173}
174
175static inline int
176imemo_type_p(VALUE imemo, enum imemo_type imemo_type)
177{
178 if (LIKELY(!RB_SPECIAL_CONST_P(imemo))) {
179 /* fixed at compile time if imemo_type is given. */
180 const VALUE mask = (IMEMO_MASK << FL_USHIFT) | RUBY_T_MASK;
181 const VALUE expected_type = (imemo_type << FL_USHIFT) | T_IMEMO;
182 /* fixed at runtime. */
183 return expected_type == (RBASIC(imemo)->flags & mask);
184 }
185 else {
186 return 0;
187 }
188}
189
190#define IMEMO_TYPE_P(v, t) imemo_type_p((VALUE)(v), t)
191
192static inline bool
193imemo_throw_data_p(VALUE imemo)
194{
195 return RB_TYPE_P(imemo, T_IMEMO);
196}
197
198static inline struct vm_ifunc *
199rb_vm_ifunc_proc_new(rb_block_call_func_t func, const void *data)
200{
201 return rb_vm_ifunc_new(func, data, 0, UNLIMITED_ARGUMENTS);
202}
203
204static inline VALUE
205rb_imemo_tmpbuf_auto_free_pointer(void)
206{
207 return rb_imemo_new(imemo_tmpbuf, 0, sizeof(rb_imemo_tmpbuf_t));
208}
209
210static inline void *
211RB_IMEMO_TMPBUF_PTR(VALUE v)
212{
213 const struct rb_imemo_tmpbuf_struct *p = (const void *)v;
214 return p->ptr;
215}
216
217static inline void *
218rb_imemo_tmpbuf_set_ptr(VALUE v, void *ptr)
219{
220 return ((rb_imemo_tmpbuf_t *)v)->ptr = ptr;
221}
222
223static inline VALUE
224rb_imemo_tmpbuf_auto_free_pointer_new_from_an_RString(VALUE str)
225{
226 const void *src;
227 VALUE imemo;
228 rb_imemo_tmpbuf_t *tmpbuf;
229 void *dst;
230 size_t len;
231
232 StringValue(str);
233 /* create tmpbuf to keep the pointer before xmalloc */
234 imemo = rb_imemo_tmpbuf_auto_free_pointer();
235 tmpbuf = (rb_imemo_tmpbuf_t *)imemo;
236 len = RSTRING_LEN(str);
237 src = RSTRING_PTR(str);
238 dst = ruby_xmalloc(len);
239 memcpy(dst, src, len);
240 tmpbuf->ptr = dst;
241 return imemo;
242}
243
244static inline void
245MEMO_V1_SET(struct MEMO *m, VALUE v)
246{
247 RB_OBJ_WRITE(m, &m->v1, v);
248}
249
250static inline void
251MEMO_V2_SET(struct MEMO *m, VALUE v)
252{
253 RB_OBJ_WRITE(m, &m->v2, v);
254}
255
256struct rb_fields {
257 struct RBasic basic;
258 union {
259 struct {
260 VALUE fields[1];
261 } embed;
262 struct {
263 VALUE *ptr;
264 } external;
265 struct {
266 // Note: the st_table could be embedded, but complex T_CLASS should be rare to
267 // non-existent, so not really worth the trouble.
268 st_table *table;
269 } complex;
270 } as;
271};
272
273#define OBJ_FIELD_EXTERNAL IMEMO_FL_USER0
274#define IMEMO_OBJ_FIELDS(fields) ((struct rb_fields *)fields)
275
276VALUE rb_imemo_fields_new(VALUE klass, size_t capa);
277VALUE rb_imemo_fields_new_complex(VALUE klass, size_t capa);
278VALUE rb_imemo_fields_new_complex_tbl(VALUE klass, st_table *tbl);
279VALUE rb_imemo_fields_clone(VALUE fields_obj);
280void rb_imemo_fields_clear(VALUE fields_obj);
281
282static inline VALUE *
283rb_imemo_fields_ptr(VALUE obj_fields)
284{
285 if (!obj_fields) {
286 return NULL;
287 }
288
289 RUBY_ASSERT(IMEMO_TYPE_P(obj_fields, imemo_fields));
290
291 if (RB_UNLIKELY(FL_TEST_RAW(obj_fields, OBJ_FIELD_EXTERNAL))) {
292 return IMEMO_OBJ_FIELDS(obj_fields)->as.external.ptr;
293 }
294 else {
295 return IMEMO_OBJ_FIELDS(obj_fields)->as.embed.fields;
296 }
297}
298
299static inline st_table *
300rb_imemo_fields_complex_tbl(VALUE obj_fields)
301{
302 if (!obj_fields) {
303 return NULL;
304 }
305
306 RUBY_ASSERT(IMEMO_TYPE_P(obj_fields, imemo_fields));
307
308 return IMEMO_OBJ_FIELDS(obj_fields)->as.complex.table;
309}
310
311#endif /* INTERNAL_IMEMO_H */
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
#define T_IMEMO
Old name of RUBY_T_IMEMO.
Definition value_type.h:67
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
Definition fl_type.h:131
#define FL_USHIFT
Old name of RUBY_FL_USHIFT.
Definition fl_type.h:68
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
Definition gc.h:603
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
Definition error.h:35
int capa
Designed capacity of the buffer.
Definition io.h:11
int len
Length of the buffer.
Definition io.h:8
rb_block_call_func * rb_block_call_func_t
Shorthand type that represents an iterator-written-in-C function pointer.
Definition iterator.h:88
VALUE type(ANYARGS)
ANYARGS-ed function type.
#define RBASIC(obj)
Convenient casting macro.
Definition rbasic.h:40
#define StringValue(v)
Ensures that the parameter object is a String.
Definition rstring.h:66
static bool RB_SPECIAL_CONST_P(VALUE obj)
Checks if the given object is of enum ruby_special_consts.
C99 shim for <stdbool.h>
MEMO.
Definition imemo.h:106
Ruby object's base components.
Definition rbasic.h:69
Definition st.h:79
IFUNC (Internal FUNCtion)
Definition imemo.h:85
SVAR (Special VARiable)
Definition imemo.h:49
const VALUE cref_or_me
class reference or rb_method_entry_t
Definition imemo.h:51
THROW_DATA.
Definition imemo.h:58
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
Definition value.h:69
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40
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_MASK
Bitmask of ruby_value_type.
Definition value_type.h:145