* Default value of +--jit-min-calls+ is changed from 5 to 10,000

=== Miscellaneous changes

* Require compilers to support C99 [Misc #15347]

rb_name_class(obj, id);

rb_const_set((rb_cObject ? rb_cObject : obj), id, obj);

return obj;

}

" (%"PRIsVALUE" is given but was %"PRIsVALUE")",

outer, rb_id2str(id), RCLASS_SUPER(klass), super);

}

return klass;

}

if (!super) {

rb_set_class_path_string(klass, outer, rb_id2str(id));

rb_const_set(outer, id, klass);

rb_class_inherited(super, klass);

rb_gc_register_mark_object(klass);

return klass;

rb_raise(rb_eTypeError, "%s is not a module (%"PRIsVALUE")",

name, rb_obj_class(module));

}

return module;

}

module = rb_define_module_id(id);

rb_vm_add_root_module(id, module);

rb_const_set(rb_cObject, id, module);

return module;

typedef struct rb_const_entry_struct {

rb_const_flag_t flag;

int line;

} rb_const_entry_t;

VALUE rb_mod_private_constant(int argc, const VALUE *argv, VALUE obj);

eGeneratorError = rb_path2class("JSON::GeneratorError");

eNestingError = rb_path2class("JSON::NestingError");

cState = rb_define_class_under(mGenerator, "State", rb_cObject);

rb_define_alloc_func(cState, cState_s_allocate);

cParser = rb_define_class_under(mExt, "Parser", rb_cObject);

eParserError = rb_path2class("JSON::ParserError");

eNestingError = rb_path2class("JSON::NestingError");

rb_define_alloc_func(cParser, cJSON_parser_s_allocate);

rb_define_method(cParser, "initialize", cParser_initialize, -1);

rb_define_method(cParser, "parse", cParser_parse, 0);

#include "ruby_atomic.h"

#include "probes.h"

#include "id_table.h"

#include <stdio.h>

#include <stdarg.h>

#include <setjmp.h>

VALUE flags; /* always 0 for freed obj */

struct RVALUE *next;

} free;

struct RBasic basic;

struct RObject object;

struct RClass klass;

#if USE_RGENGC

size_t minor_gc_count;

size_t major_gc_count;

#if RGENGC_PROFILE > 0

size_t total_generated_normal_object_count;

size_t total_generated_shady_object_count;

size_t error_count;

#endif

} rgengc;

#if GC_ENABLE_INCREMENTAL_MARK

struct {

size_t pooled_slots;

#endif

#endif /* USE_RGENGC */

#if GC_DEBUG_STRESS_TO_CLASS

VALUE stress_to_class;

#endif

#if USE_RGENGC

bits_t wb_unprotected_bits[HEAP_PAGE_BITMAP_LIMIT];

#endif

/* the following three bitmaps are cleared at the beginning of full GC */

bits_t mark_bits[HEAP_PAGE_BITMAP_LIMIT];

#if USE_RGENGC

/* getting bitmap */

#define GET_HEAP_MARK_BITS(x) (&GET_HEAP_PAGE(x)->mark_bits[0])

#if USE_RGENGC

#define GET_HEAP_UNCOLLECTIBLE_BITS(x) (&GET_HEAP_PAGE(x)->uncollectible_bits[0])

#define GET_HEAP_WB_UNPROTECTED_BITS(x) (&GET_HEAP_PAGE(x)->wb_unprotected_bits[0])

int ruby_disable_gc = 0;

void rb_iseq_mark(const rb_iseq_t *iseq);

void rb_iseq_free(const rb_iseq_t *iseq);

void rb_gcdebug_print_obj_condition(VALUE obj);

static void gc_sweep_continue(rb_objspace_t *objspace, rb_heap_t *heap);

static inline void gc_mark(rb_objspace_t *objspace, VALUE ptr);

static void gc_mark_ptr(rb_objspace_t *objspace, VALUE ptr);

NO_SANITIZE("memory", static void gc_mark_maybe(rb_objspace_t *objspace, VALUE ptr));

static void gc_mark_children(rb_objspace_t *objspace, VALUE ptr);

static int gc_mark_stacked_objects_incremental(rb_objspace_t *, size_t count);

static inline void gc_prof_set_malloc_info(rb_objspace_t *);

static inline void gc_prof_set_heap_info(rb_objspace_t *);

#define gc_prof_record(objspace) (objspace)->profile.current_record

#define gc_prof_enabled(objspace) ((objspace)->profile.run && (objspace)->profile.current_record)

#define FL_UNSET2(x,f) FL_CHECK2("FL_UNSET2", x, RBASIC(x)->flags &= ~(f))

#define RVALUE_MARK_BITMAP(obj) MARKED_IN_BITMAP(GET_HEAP_MARK_BITS(obj), (obj))

#define RVALUE_PAGE_MARKED(page, obj) MARKED_IN_BITMAP((page)->mark_bits, (obj))

#if USE_RGENGC

#endif

static inline int

RVALUE_MARKED(VALUE obj)

{

check_rvalue_consistency(obj);

return RVALUE_MARK_BITMAP(obj) != 0;

}

#if USE_RGENGC

static inline int

RVALUE_WB_UNPROTECTED(VALUE obj)

objspace->eden_heap.total_pages = 0;

objspace->eden_heap.total_slots = 0;

}

free_stack_chunks(&objspace->mark_stack);

#if !(defined(ENABLE_VM_OBJSPACE) && ENABLE_VM_OBJSPACE)

if (objspace == &rb_objspace) return;

static inline VALUE

newobj_init(VALUE klass, VALUE flags, VALUE v1, VALUE v2, VALUE v3, int wb_protected, rb_objspace_t *objspace, VALUE obj)

{

/* OBJSETUP */

RBASIC(obj)->flags = flags;

FL_UNSET(obj, FL_EXIVAR);

}

#if USE_RGENGC

if (RVALUE_WB_UNPROTECTED(obj)) CLEAR_IN_BITMAP(GET_HEAP_WB_UNPROTECTED_BITS(obj), obj);

break;

case T_RATIONAL:

case T_COMPLEX:

break;

case T_ICLASS:

/* Basically , T_ICLASS shares table with the module */

{

rb_objspace_t *objspace = &rb_objspace;

gc_stress_set(objspace, ruby_initial_gc_stress);

#if RGENGC_ESTIMATE_OLDMALLOC

UNEXPECTED_NODE(internal_object_p);

break;

case T_NONE:

case T_IMEMO:

case T_ICLASS:

case T_ZOMBIE:

#endif

rb_objspace_t *objspace = &rb_objspace;

VALUE ptr;

void *p0;

ptr = NUM2PTR(objid);

if (FLONUM_P(ptr)) return (VALUE)ptr;

ptr = obj_id_to_ref(objid);

if ((ptr % sizeof(RVALUE)) == (4 << 2)) {

ID symid = ptr / sizeof(RVALUE);

if (rb_id2str(symid) == 0)

return (VALUE)ptr;

}

/*

* Document-method: __id__

* Document-method: object_id

* 24 if 32-bit, double is 8-byte aligned

* 40 if 64-bit

*/

}

#include "regint.h"

break;

case T_ZOMBIE:

break;

default:

COUNT_TYPE(T_NODE);

COUNT_TYPE(T_ICLASS);

COUNT_TYPE(T_ZOMBIE);

#undef COUNT_TYPE

default: return INT2NUM(type); break;

}

VALUE v;

while (n--) {

v = *x;

x++;

}

}

}

static void

{

long i;

for (i=0; i<n; i++) {

}

}

rb_gc_mark_values(long n, const VALUE *values)

{

rb_objspace_t *objspace = &rb_objspace;

}

static int

{

rb_objspace_t *objspace = (rb_objspace_t *)data;

gc_mark(objspace, (VALUE)value);

return ST_CONTINUE;

}

static void

mark_tbl(rb_objspace_t *objspace, st_table *tbl)

{

{

rb_objspace_t *objspace = (rb_objspace_t *)data;

gc_mark(objspace, (VALUE)value);

return ST_CONTINUE;

}

mark_tbl(&rb_objspace, tbl);

}

static void

{

(void)VALGRIND_MAKE_MEM_DEFINED(&obj, sizeof(obj));

if (is_pointer_to_heap(objspace, (void *)obj)) {

unpoison_object(obj, false);

type = BUILTIN_TYPE(obj);

gc_mark_ptr(objspace, obj);

}

if (ptr) {

poison_object(obj);

}

}

}

void

rb_gc_mark_maybe(VALUE obj)

{

}

static inline int

}

static inline void

gc_mark(rb_objspace_t *objspace, VALUE obj)

{

if (!is_markable_object(objspace, obj)) return;

}

void

{

gc_mark(&rb_objspace, ptr);

}

/* CAUTION: THIS FUNCTION ENABLE *ONLY BEFORE* SWEEPING.

* This function is only for GC_END_MARK timing.

*/

return RVALUE_MARKED(obj) ? TRUE : FALSE;

}

static inline void

gc_mark_set_parent(rb_objspace_t *objspace, VALUE obj)

{

{

const rb_env_t *env = (const rb_env_t *)obj;

GC_ASSERT(VM_ENV_ESCAPED_P(env->ep));

VM_ENV_FLAGS_SET(env->ep, VM_ENV_FLAG_WB_REQUIRED);

gc_mark(objspace, (VALUE)env->iseq);

}

return;

gc_mark(objspace, RCLASS_SUPER((VALUE)obj));

}

if (!RCLASS_EXT(obj)) break;

mark_const_tbl(objspace, RCLASS_CONST_TBL(obj));

break;

#if GC_DEBUG

rb_gcdebug_print_obj_condition((VALUE)obj);

#endif

if (BUILTIN_TYPE(obj) == T_NONE) rb_bug("rb_gc_mark(): %p is T_NONE", (void *)obj);

if (BUILTIN_TYPE(obj) == T_ZOMBIE) rb_bug("rb_gc_mark(): %p is T_ZOMBIE", (void *)obj);

rb_bug("rb_gc_mark(): unknown data type 0x%x(%p) %s",

/* count objects */

data->live_object_count++;

#if USE_RGENGC

/* check health of children */

list_for_each(&heap->pages, page, page_node) {

memset(&page->mark_bits[0], 0, HEAP_PAGE_BITMAP_SIZE);

memset(&page->marking_bits[0], 0, HEAP_PAGE_BITMAP_SIZE);

memset(&page->uncollectible_bits[0], 0, HEAP_PAGE_BITMAP_SIZE);

page->flags.has_uncollectible_shady_objects = FALSE;

size_t n = 0;

static ID ID_marked;

#if USE_RGENGC

#endif

if (!ID_marked) {

I(old);

I(marking);

I(uncollectible);

#endif

#undef I

}

if (MARKED_IN_BITMAP(GET_HEAP_MARKING_BITS(obj), obj) && n<max) flags[n++] = ID_marking;

#endif

if (MARKED_IN_BITMAP(GET_HEAP_MARK_BITS(obj), obj) && n<max) flags[n++] = ID_marked;

return n;

}

return Qnil;

}

VALUE

rb_gc_start(void)

{

#if USE_RGENGC

gc_stat_sym_minor_gc_count,

gc_stat_sym_major_gc_count,

gc_stat_sym_remembered_wb_unprotected_objects,

gc_stat_sym_remembered_wb_unprotected_objects_limit,

gc_stat_sym_old_objects,

S(malloc_increase_bytes_limit);

#if USE_RGENGC

S(minor_gc_count);

S(major_gc_count);

S(remembered_wb_unprotected_objects);

S(remembered_wb_unprotected_objects_limit);

SET(malloc_increase_bytes_limit, malloc_limit);

#if USE_RGENGC

SET(minor_gc_count, objspace->profile.minor_gc_count);

SET(major_gc_count, objspace->profile.major_gc_count);

SET(remembered_wb_unprotected_objects, objspace->rgengc.uncollectible_wb_unprotected_objects);

SET(remembered_wb_unprotected_objects_limit, objspace->rgengc.uncollectible_wb_unprotected_objects_limit);

}

#endif

static void

wmap_mark(void *ptr)

{

struct weakmap *w = ptr;

#if WMAP_DELETE_DEAD_OBJECT_IN_MARK

if (w->obj2wmap) st_foreach(w->obj2wmap, wmap_mark_map, (st_data_t)&rb_objspace);

#endif

TYPE_NAME(T_UNDEF);

TYPE_NAME(T_IMEMO);

TYPE_NAME(T_ICLASS);

TYPE_NAME(T_ZOMBIE);

case T_DATA:

if (obj && rb_objspace_data_type_name(obj)) {

static void

rb_raw_iseq_info(char *buff, const int buff_size, const rb_iseq_t *iseq)

{

VALUE path = rb_iseq_path(iseq);

VALUE n = iseq->body->location.first_lineno;

snprintf(buff, buff_size, "%s %s@%s:%d", buff,

const int age = RVALUE_FLAGS_AGE(RBASIC(obj)->flags);

if (is_pointer_to_heap(&rb_objspace, (void *)obj)) {

(void *)obj, age,

C(RVALUE_UNCOLLECTIBLE_BITMAP(obj), "L"),

C(RVALUE_MARK_BITMAP(obj), "M"),

C(RVALUE_MARKING_BITMAP(obj), "R"),

C(RVALUE_WB_UNPROTECTED_BITMAP(obj), "U"),

obj_type_name(obj));

snprintf(buff, buff_size, "%s (temporary internal)", buff);

}

else {

VALUE class_path = rb_class_path_cached(RBASIC(obj)->klass);

if (!NIL_P(class_path)) {

snprintf(buff, buff_size, "%s (%s)", buff, RSTRING_PTR(class_path));

}

}

#if GC_DEBUG

snprintf(buff, buff_size, "%s %s", buff, RSTRING_PTR(obj));

break;

}

case T_HASH: {

snprintf(buff, buff_size, "%s [%c%c] %d", buff,

RHASH_AR_TABLE_P(obj) ? 'A' : 'S',

fprintf(stderr, "created at: %s:%d\n", RANY(obj)->file, RANY(obj)->line);

if (is_pointer_to_heap(objspace, (void *)obj)) {

fprintf(stderr, "pointer to heap?: true\n");

}

}

fprintf(stderr, "marked? : %s\n", MARKED_IN_BITMAP(GET_HEAP_MARK_BITS(obj), obj) ? "true" : "false");

#if USE_RGENGC

fprintf(stderr, "age? : %d\n", RVALUE_AGE(obj));

fprintf(stderr, "old? : %s\n", RVALUE_OLD_P(obj) ? "true" : "false");

rb_define_singleton_method(rb_mGC, "count", gc_count, 0);

rb_define_singleton_method(rb_mGC, "stat", gc_stat, -1);

rb_define_singleton_method(rb_mGC, "latest_gc_info", gc_latest_gc_info, -1);

rb_define_method(rb_mGC, "garbage_collect", gc_start_internal, -1);

gc_constants = rb_hash_new();

/* internal methods */

rb_define_singleton_method(rb_mGC, "verify_internal_consistency", gc_verify_internal_consistency, 0);

rb_define_singleton_method(rb_mGC, "verify_transient_heap_internal_consistency", gc_verify_transient_heap_internal_consistency, 0);

#if MALLOC_ALLOCATED_SIZE

rb_define_singleton_method(rb_mGC, "malloc_allocated_size", gc_malloc_allocated_size, 0);

#define RUBY_GC_INFO if(0)printf

#endif

#define RUBY_MARK_UNLESS_NULL(ptr) do { \

VALUE markobj = (ptr); \

if (RTEST(markobj)) {rb_gc_mark(markobj);} \

}

static int

{

if (RHASH_AR_TABLE_SIZE(hash) > 0) {

unsigned i, bound = RHASH_AR_TABLE_BOUND(hash);

case ST_CHECK:

case ST_STOP:

return 0;

case ST_DELETE:

ar_clear_entry(RHASH_AR_TABLE_REF(hash, i));

RHASH_AR_TABLE_SIZE_DEC(hash);

}

static int

ar_foreach_check(VALUE hash, int (*func)(ANYARGS), st_data_t arg,

st_data_t never)

{

case ST_CONTINUE:

break;

case ST_STOP:

return 0;

case ST_DELETE: {

if (!ar_empty_entry(cur_entry)) {

}

}

static VALUE

hash_foreach_call(VALUE arg)

{

}

void

rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, void *data)

{

int i, capa = tbl->capa;

ID_TABLE_CONTINUE = ST_CONTINUE,

ID_TABLE_STOP = ST_STOP,

ID_TABLE_DELETE = ST_DELETE,

ID_TABLE_ITERATOR_RESULT_END

};

int rb_id_table_lookup(struct rb_id_table *tbl, ID id, VALUE *valp);

int rb_id_table_delete(struct rb_id_table *tbl, ID id);

typedef enum rb_id_table_iterator_result rb_id_table_foreach_func_t(ID id, VALUE val, void *data);

typedef enum rb_id_table_iterator_result rb_id_table_foreach_values_func_t(VALUE val, void *data);

void rb_id_table_foreach(struct rb_id_table *tbl, rb_id_table_foreach_func_t *func, void *data);

void rb_id_table_foreach_values(struct rb_id_table *tbl, rb_id_table_foreach_values_func_t *func, void *data);

#endif /* RUBY_ID_TABLE_H */

PUREFUNC(int rb_during_gc(void));

void rb_gc_mark_locations(const VALUE*, const VALUE*);

void rb_mark_tbl(struct st_table*);

void rb_mark_set(struct st_table*);

void rb_mark_hash(struct st_table*);

void rb_gc_mark_maybe(VALUE);

void rb_gc_mark(VALUE);

void rb_gc_force_recycle(VALUE);

void rb_gc(void);

void rb_gc_copy_finalizer(VALUE,VALUE);

VALUE rb_obj_freeze(VALUE);

PUREFUNC(VALUE rb_obj_frozen_p(VALUE));

VALUE rb_obj_id(VALUE);

VALUE rb_obj_class(VALUE);

PUREFUNC(VALUE rb_class_real(VALUE));

PUREFUNC(VALUE rb_class_inherited_p(VALUE, VALUE));

RUBY_T_NODE = 0x1b,

RUBY_T_ICLASS = 0x1c,

RUBY_T_ZOMBIE = 0x1d,

RUBY_T_MASK = 0x1f

};

#define T_UNDEF RUBY_T_UNDEF

#define T_NODE RUBY_T_NODE

#define T_ZOMBIE RUBY_T_ZOMBIE

#define T_MASK RUBY_T_MASK

#define RB_BUILTIN_TYPE(x) (int)(((struct RBasic*)(x))->flags & RUBY_T_MASK)

RUBY_FL_FINALIZE = (1<<7),

RUBY_FL_TAINT = (1<<8),

RUBY_FL_UNTRUSTED = RUBY_FL_TAINT,

RUBY_FL_EXIVAR = (1<<10),

RUBY_FL_FREEZE = (1<<11),

struct RUBY_ALIGNAS(SIZEOF_VALUE) RBasic {

VALUE flags;

};

VALUE rb_obj_hide(VALUE obj);

struct RRegexp {

struct RBasic basic;

struct re_pattern_buffer *ptr;

unsigned long usecnt;

};

#define RREGEXP_PTR(r) (RREGEXP(r)->ptr)

void (*dmark)(void*);

void (*dfree)(void*);

size_t (*dsize)(const void *);

This array *must* be filled with ZERO. */

} function;

const rb_data_type_t *parent;

#define RBIGNUM_NEGATIVE_P(b) (RBIGNUM_SIGN(b)==0)

#define R_CAST(st) (struct st*)

#define RBASIC(obj) (R_CAST(RBasic)(obj))

#define ROBJECT(obj) (R_CAST(RObject)(obj))

#define RCLASS(obj) (R_CAST(RClass)(obj))

#define FL_FINALIZE ((VALUE)RUBY_FL_FINALIZE)

#define FL_TAINT ((VALUE)RUBY_FL_TAINT)

#define FL_UNTRUSTED ((VALUE)RUBY_FL_UNTRUSTED)

#define FL_EXIVAR ((VALUE)RUBY_FL_EXIVAR)

#define FL_FREEZE ((VALUE)RUBY_FL_FREEZE)

#define st_is_member(table,key) st_lookup((table),(key),(st_data_t *)0)

st_table *st_init_table(const struct st_hash_type *);

st_table *st_init_table_with_size(const struct st_hash_type *, st_index_t);

* results of hash() are same and compare() returns 0, otherwise the

* behavior is undefined */

int st_update(st_table *table, st_data_t key, st_update_callback_func *func, st_data_t arg);

int st_foreach(st_table *, int (*)(ANYARGS), st_data_t);

int st_foreach_check(st_table *, int (*)(ANYARGS), st_data_t, st_data_t);

st_index_t st_keys(st_table *table, st_data_t *keys, st_index_t size);

struct RRational {

struct RBasic basic;

};

#define RRATIONAL(obj) (R_CAST(RRational)(obj))

struct RComplex {

struct RBasic basic;

};

#define RCOMPLEX(obj) (R_CAST(RComplex)(obj))

st_table *st;

struct ar_table_struct *ar; /* possibly 0 */

} as;

};

#ifdef RHASH_ITER_LEV

# define RHASH_SIZE(h) (RHASH_AR_TABLE_P(h) ? RHASH_AR_TABLE_SIZE_RAW(h) : RHASH_ST_SIZE(h))

#endif /* #ifdef RHASH_ITER_LEV */

/* missing/setproctitle.c */

#ifndef HAVE_SETPROCTITLE

extern void ruby_init_setproctitle(int argc, char *argv[]);

*/

rb_subclass_entry_t **module_subclasses;

rb_serial_t class_serial;

VALUE refined_class;

rb_alloc_func_t allocator;

};

/*! SVAR (Special VARiable) */

struct vm_svar {

VALUE flags;

};

struct vm_throw_data {

VALUE flags;

VALUE reserved;

const struct rb_control_frame_struct *catch_frame;

VALUE throw_state;

};

VALUE flags;

VALUE reserved;

VALUE (*func)(ANYARGS);

struct vm_ifunc_argc argc;

};

struct MEMO {

VALUE flags;

VALUE reserved;

union {

long cnt;

long state;

VALUE (*func)(ANYARGS);

} u3;

};

int rb_hash_stlike_lookup(VALUE hash, st_data_t key, st_data_t *pval);

int rb_hash_stlike_delete(VALUE hash, st_data_t *pkey, st_data_t *pval);

int rb_hash_stlike_foreach(VALUE hash, int (*func)(ANYARGS), st_data_t arg);

int rb_hash_stlike_update(VALUE hash, st_data_t key, st_update_callback_func func, st_data_t arg);

/* inits.c */

/* variable.c (export) */

void rb_mark_generic_ivar(VALUE);

VALUE rb_const_missing(VALUE klass, VALUE name);

int rb_class_ivar_set(VALUE klass, ID vid, VALUE value);

st_table *rb_st_copy(VALUE obj, struct st_table *orig_tbl);

size_t rb_obj_memsize_of(VALUE);

void rb_gc_verify_internal_consistency(void);

size_t rb_obj_gc_flags(VALUE, ID[], size_t);

void rb_gc_mark_values(long n, const VALUE *values);

#if IMEMO_DEBUG

VALUE rb_imemo_new_debug(enum imemo_type type, VALUE v1, VALUE v2, VALUE v3, VALUE v0, const char *file, int line);

return (VALUE)addr;

}

typedef VALUE rb_vm_insns_translator_t(const void *addr);

static int

{

VALUE insn = translator((void *)code[pos]);

int len = insn_len(insn);

{

VALUE op = code[pos + op_no + 1];

if (!SPECIAL_CONST_P(op)) {

}

break;

}

{

union iseq_inline_storage_entry *const is = (union iseq_inline_storage_entry *)code[pos + op_no + 1];

if (is->once.value) {

}

break;

}

rb_iseq_each_value(const rb_iseq_t *iseq, iseq_value_itr_t * func, void *data)

{

unsigned int size;

size_t n;

rb_vm_insns_translator_t * translator;

const struct rb_iseq_constant_body *const body = iseq->body;

}

}

each_insn_value(void *ctx, VALUE obj)

{

}

void

rb_iseq_each_value(iseq, each_insn_value, NULL);

}

if (body->param.flags.has_kw && ISEQ_COMPILE_DATA(iseq) == NULL) {

const struct rb_iseq_param_keyword *const keyword = body->param.keyword;

const struct iseq_catch_table_entry *entry;

entry = &table->entries[i];

if (entry->iseq) {

}

}

}

}

else if (FL_TEST_RAW(iseq, ISEQ_USE_COMPILE_DATA)) {

const struct iseq_compile_data *const compile_data = ISEQ_COMPILE_DATA(iseq);

RUBY_MARK_UNLESS_NULL(compile_data->err_info);

}

else {

/* executable */

* CATCH_TYPE_REDO, CATCH_TYPE_NEXT:

* NULL.

*/

unsigned int start;

unsigned int end;

/*! CREF (Class REFerence) */

typedef struct rb_cref_struct {

VALUE flags;

const rb_scope_visibility_t scope_visi;

} rb_cref_t;

typedef struct rb_method_entry_struct {

VALUE flags;

struct rb_method_definition_struct * const def;

ID called_id;

} rb_method_entry_t;

typedef struct rb_callable_method_entry_struct { /* same fields with rb_method_entry_t */

#endif

typedef struct rb_method_iseq_struct {

} rb_method_iseq_t; /* check rb_add_method_iseq() when modify the fields */

typedef struct rb_method_cfunc_struct {

typedef struct rb_method_attr_struct {

ID id;

} rb_method_attr_t;

typedef struct rb_method_alias_struct {

} rb_method_alias_t;

typedef struct rb_method_refined_struct {

} rb_method_refined_t;

typedef struct rb_method_bmethod_struct {

struct rb_hook_list_struct *hooks;

} rb_method_bmethod_t;

different for ST_CHECK and when the current element is removed

during traversing. */

static inline int

int check_p)

{

st_index_t bin;

rebuilds_num = tab->rebuilds_num;

hash = curr_entry_ptr->hash;

retval = (*func)(key, curr_entry_ptr->record, arg, 0);

if (rebuilds_num != tab->rebuilds_num) {

retry:

entries = tab->entries;

curr_entry_ptr = &entries[i];

}

switch (retval) {

case ST_CONTINUE:

break;

case ST_CHECK:

}

int

st_foreach(st_table *tab, int (*func)(ANYARGS), st_data_t arg)

{

}

/* See comments for function st_delete_safe. */

st_foreach_check(st_table *tab, int (*func)(ANYARGS), st_data_t arg,

st_data_t never ATTRIBUTE_UNUSED)

{

}

/* Set up array KEYS by at most SIZE keys of head table TAB entries.

ID_ENTRY_SIZE

};

static const struct st_hash_type symhash = {

rb_str_hash_cmp,

typedef uint32_t rb_id_serial_t;

static inline rb_id_serial_t

rb_id_to_serial(ID id)

{

end

def test_profiler_clear

assert_separately %w[--disable-gem], __FILE__, __LINE__, <<-'eom', timeout: 30

GC::Profiler.enable

struct exec_recursive_params p;

int outermost;

p.list = recursive_list_access(sym);

p.obj = obj;

p.pairid = pairid;

p.arg = arg;

VALUE

rb_exec_recursive_paired(VALUE (*func) (VALUE, VALUE, int), VALUE obj, VALUE paired_obj, VALUE arg)

{

}

/*

VALUE

rb_exec_recursive_paired_outer(VALUE (*func) (VALUE, VALUE, int), VALUE obj, VALUE paired_obj, VALUE arg)

{

}

/*

}

}

void

rb_transient_heap_start_marking(int full_marking)

{

void rb_transient_heap_promote(VALUE obj);

void rb_transient_heap_start_marking(int full_marking);

void rb_transient_heap_finish_marking(void);

/* for debug API */

void rb_transient_heap_dump(void);

#define rb_transient_heap_verify() ((void)0)

#define rb_transient_heap_promote(obj) ((void)0)

#define rb_transient_heap_start_marking(full_marking) ((void)0)

#define rb_transient_heap_finish_marking() ((void)0)

#define rb_transient_heap_mark(obj, ptr) ((void)0)

}

void

rb_free_generic_ivar(VALUE obj)

{

st_data_t key = (st_data_t)obj;

static void

autoload_mark(void *ptr)

{

}

static void

return st_memsize(tbl);

}

static const rb_data_type_t autoload_data_type = {

"autoload",

0, 0, RUBY_TYPED_FREE_IMMEDIATELY

};

};

static void

autoload_i_mark(void *ptr)

{

struct autoload_data_i *p = ptr;

/* allow GC to free us if no modules refer to this via autoload_const.ad */

if (list_empty(&p->constants)) {

static const rb_data_type_t autoload_data_i_type = {

"autoload_i",

0, 0, RUBY_TYPED_FREE_IMMEDIATELY

};

if (!rb_is_const_id(id)) {

rb_warn("rb_define_const: invalid name `%s' for constant", name);

}

rb_const_set(klass, id, val);

}

/* vm */

void

rb_vm_mark(void *ptr)

{

RUBY_MARK_ENTER("vm");

if (ptr) {

rb_vm_t *vm = ptr;

rb_thread_t *th = 0;

list_for_each(&vm->living_threads, th, vmlt_node) {

rb_gc_mark(th->self);

}

rb_gc_mark(vm->thgroup_default);

rb_gc_mark(vm->mark_object_ary);

rb_gc_mark(vm->load_path);

rb_gc_mark(vm->load_path_snapshot);

RUBY_MARK_UNLESS_NULL(vm->load_path_check_cache);

rb_gc_mark(vm->top_self);

RUBY_MARK_UNLESS_NULL(vm->coverages);

rb_gc_mark(vm->defined_module_hash);

if (vm->loading_table) {

rb_mark_tbl(vm->loading_table);

rb_control_frame_t *cfp = ec->cfp;

rb_control_frame_t *limit_cfp = (void *)(ec->vm_stack + ec->vm_stack_size);

while (cfp != limit_cfp) {

const VALUE *ep = cfp->ep;

} type; /* instruction sequence type */

unsigned int iseq_size;

/**

* parameter information

int bits_start;

int rest_start;

const ID *table;

} *keyword;

} param;

const ID *local_table; /* must free */

/* catch table */

/* for child iseq */

const struct rb_iseq_struct *parent_iseq;

typedef struct {

VALUE flags; /* imemo header */

const VALUE *ep;

const VALUE *env;

unsigned int env_size;

case type_case(T_NODE);

case type_case(T_ICLASS);

case type_case(T_ZOMBIE);

case T_MASK: break;

}

#undef type_case