1#ifndef INTERNAL_IMEMO_H
2#define INTERNAL_IMEMO_H
11#include "ruby/internal/config.h"
14#include "internal/array.h"
18#define IMEMO_MASK 0x0f
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
42 imemo_constcache = 12,
61 const VALUE throw_obj;
66#define THROW_DATA_CONSUMED IMEMO_FL_USER0
71#if SIZEOF_INT * 2 > SIZEOF_VALUE
92#define IFUNC_YIELD_OPTIMIZABLE IMEMO_FL_USER0
117#define IMEMO_NEW(T, type, v0) ((T *)rb_imemo_new((type), (v0), sizeof(T)))
121#define THROW_DATA_P(err) imemo_throw_data_p((VALUE)err)
122#define MEMO_CAST(m) ((struct MEMO *)(m))
123#define MEMO_FOR(type, value) ((type *)RARRAY_PTR(value))
124#define NEW_MEMO_FOR(type, value) \
125 ((value) = rb_ary_hidden_new_fill(type_roomof(type, VALUE)), MEMO_FOR(type, value))
126#define NEW_PARTIAL_MEMO_FOR(type, value, member) \
127 ((value) = rb_ary_hidden_new_fill(type_roomof(type, VALUE)), \
128 rb_ary_set_len((value), offsetof(type, member) / sizeof(VALUE)), \
129 MEMO_FOR(type, value))
131#ifndef RUBY_RUBYPARSER_H
135VALUE rb_imemo_tmpbuf_new(
void);
137static inline enum imemo_type imemo_type(
VALUE imemo);
138static inline int imemo_type_p(
VALUE imemo,
enum imemo_type imemo_type);
139static inline bool imemo_throw_data_p(
VALUE imemo);
141static inline void *RB_IMEMO_TMPBUF_PTR(
VALUE v);
142static inline void *rb_imemo_tmpbuf_set_ptr(
VALUE v,
void *ptr);
143static inline void MEMO_V1_SET(
struct MEMO *m,
VALUE v);
144static inline void MEMO_V2_SET(
struct MEMO *m,
VALUE v);
146size_t rb_imemo_memsize(
VALUE obj);
147void rb_imemo_mark_and_move(
VALUE obj,
bool reference_updating);
148void rb_imemo_free(
VALUE obj);
150RUBY_SYMBOL_EXPORT_BEGIN
151const char *rb_imemo_name(
enum imemo_type
type);
152RUBY_SYMBOL_EXPORT_END
154static inline struct MEMO *
157 struct MEMO *memo = IMEMO_NEW(
struct MEMO, imemo_memo, 0);
158 *((
VALUE *)&memo->v1) = a;
159 *((
VALUE *)&memo->v2) = b;
160 *((
VALUE *)&memo->u3.value) = c;
165static inline enum imemo_type
166imemo_type(
VALUE imemo)
172imemo_type_p(
VALUE imemo,
enum imemo_type imemo_type)
179 return expected_type == (
RBASIC(imemo)->flags & mask);
186#define IMEMO_TYPE_P(v, t) imemo_type_p((VALUE)(v), t)
189imemo_throw_data_p(
VALUE imemo)
201RB_IMEMO_TMPBUF_PTR(
VALUE v)
208rb_imemo_tmpbuf_set_ptr(
VALUE v,
void *ptr)
214rb_imemo_tmpbuf_new_from_an_RString(
VALUE str)
224 imemo = rb_imemo_tmpbuf_new();
226 len = RSTRING_LEN(str);
227 src = RSTRING_PTR(str);
228 dst = ruby_xmalloc(
len);
229 memcpy(dst, src,
len);
265#define OBJ_FIELD_HEAP ROBJECT_HEAP
266STATIC_ASSERT(imemo_fields_flags, OBJ_FIELD_HEAP == IMEMO_FL_USER0);
267STATIC_ASSERT(imemo_fields_embed_offset, offsetof(
struct RObject, as.ary) == offsetof(
struct rb_fields, as.embed.fields));
268STATIC_ASSERT(imemo_fields_embed_offset, offsetof(
struct RObject, as.
heap.
fields) == offsetof(
struct rb_fields, as.external.ptr));
269STATIC_ASSERT(imemo_fields_embed_offset, offsetof(
struct RObject, as.
heap.
fields) == offsetof(
struct rb_fields, as.complex.table));
271#define IMEMO_OBJ_FIELDS(fields) ((struct rb_fields *)fields)
277void rb_imemo_fields_clear(
VALUE fields_obj);
280rb_imemo_fields_owner(
VALUE fields_obj)
282 RUBY_ASSERT(IMEMO_TYPE_P(fields_obj, imemo_fields));
288rb_imemo_fields_ptr(
VALUE fields_obj)
296 if (UNLIKELY(
FL_TEST_RAW(fields_obj, OBJ_FIELD_HEAP))) {
297 return IMEMO_OBJ_FIELDS(fields_obj)->as.external.ptr;
300 return IMEMO_OBJ_FIELDS(fields_obj)->as.embed.fields;
305rb_imemo_fields_complex_tbl(
VALUE fields_obj)
316 RUBY_ASSERT((
st_table *)rb_imemo_fields_ptr(fields_obj) == IMEMO_OBJ_FIELDS(fields_obj)->as.complex.table);
318 return IMEMO_OBJ_FIELDS(fields_obj)->as.complex.table;
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
#define T_IMEMO
Old name of RUBY_T_IMEMO.
#define CLASS_OF
Old name of rb_class_of.
#define FL_TEST_RAW
Old name of RB_FL_TEST_RAW.
#define T_OBJECT
Old name of RUBY_T_OBJECT.
#define FL_USHIFT
Old name of RUBY_FL_USHIFT.
#define RB_OBJ_WRITE(old, slot, young)
Declaration of a "back" pointer.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
int capa
Designed capacity of the buffer.
int len
Length of the buffer.
rb_block_call_func * rb_block_call_func_t
Shorthand type that represents an iterator-written-in-C function pointer.
VALUE type(ANYARGS)
ANYARGS-ed function type.
#define RBASIC(obj)
Convenient casting macro.
#define StringValue(v)
Ensures that the parameter object is a String.
static bool RB_SPECIAL_CONST_P(VALUE obj)
Checks if the given object is of enum ruby_special_consts.
Ruby object's base components.
VALUE * fields
Pointer to a C array that holds instance variables.
struct RObject::@48::@49 heap
Object that use separated memory region for instance variables use this pattern.
IFUNC (Internal FUNCtion)
const VALUE cref_or_me
class reference or rb_method_entry_t
#define SIZEOF_VALUE
Identical to sizeof(VALUE), except it is a macro that can also be used inside of preprocessor directi...
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_T_MASK
Bitmask of ruby_value_type.