static void ensure_origin(VALUE klass);

static int

include_modules_at(const VALUE klass, VALUE c, VALUE module, int search_super)

{

VALUE p, iclass;

int method_changed = 0, constant_changed = 0;

struct rb_id_table *const klass_m_tbl = RCLASS_M_TBL(RCLASS_ORIGIN(klass));

if (FL_TEST(module, RCLASS_REFINED_BY_ANY)) {

ensure_origin(module);

if (klass_m_tbl && klass_m_tbl == RCLASS_M_TBL(module))

return -1;

/* ignore if the module included already in superclasses */

int type = BUILTIN_TYPE(p);

if (type == T_ICLASS) {

if (RCLASS_M_TBL(p) == RCLASS_M_TBL(module)) {

}

else if (type == T_CLASS) {

if (!search_super) break;

}

}

c = RCLASS_SET_SUPER(c, iclass);

RCLASS_SET_INCLUDER(iclass, klass);

{

VALUE m = module;

}

if (FL_TEST(klass, RMODULE_IS_REFINEMENT)) {

VALUE refined_class =

rb_refinement_module_get_refined_class(klass);

FL_SET(c, RMODULE_INCLUDED_INTO_REFINEMENT);

}

tbl = RMODULE_CONST_TBL(module);

if (tbl && rb_id_table_size(tbl)) constant_changed = 1;

skip:

module = RCLASS_SUPER(module);

}

if (constant_changed) rb_clear_constant_cache();

return method_changed;

mjit.$(OBJEXT): {$(VPATH)}thread_$(THREAD_MODEL).h

mjit.$(OBJEXT): {$(VPATH)}thread_native.h

mjit.$(OBJEXT): {$(VPATH)}util.h

mjit.$(OBJEXT): {$(VPATH)}vm_core.h

mjit.$(OBJEXT): {$(VPATH)}vm_opts.h

mjit_compile.$(OBJEXT): $(CCAN_DIR)/check_type/check_type.h

verify_call_cache(rb_iseq_t *iseq)

{

#if CPDEBUG

VALUE *original = rb_iseq_original_iseq(iseq);

size_t i = 0;

while (i < iseq->body->iseq_size) {

for (int j=0; types[j]; j++) {

if (types[j] == TS_CALLDATA) {

struct rb_call_data *cd = (struct rb_call_data *)original[i+j+1];

}

}

}

i += insn_len(insn);

}

#endif

}

DECL_ANCHOR(ret);

INIT_ANCHOR(ret);

rb_raise(rb_eArgError, "unexpected imemo_ifunc");

}

argc += kw_arg->keyword_len;

}

iseq->body->ci_size++;

const struct rb_callinfo *ci = vm_ci_new(mid, flag, argc, kw_arg);

RB_OBJ_WRITTEN(iseq, Qundef, ci);

struct rb_call_data *cd = &body->call_data[ISEQ_COMPILE_DATA(iseq)->ci_index++];

assert(ISEQ_COMPILE_DATA(iseq)->ci_index <= body->ci_size);

cd->ci = source_ci;

generated_iseq[code_index + 1 + j] = (VALUE)cd;

break;

}

}

/* note that we dump out rb_call_info but load back rb_call_data */

ibf_load_ci_entries(const struct ibf_load *load,

ibf_offset_t ci_entries_offset,

{

ibf_offset_t reading_pos = ci_entries_offset;

unsigned int i;

struct rb_call_data *cds = ZALLOC_N(struct rb_call_data, ci_size);

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

VALUE mid_index = ibf_load_small_value(load, &reading_pos);

cds[i].ci = vm_ci_new(mid, flag, argc, kwarg);

RB_OBJ_WRITTEN(load->iseq, Qundef, cds[i].ci);

}

static ibf_offset_t

ibf_dump_iseq_each(struct ibf_dump *dump, const rb_iseq_t *iseq)

load_body->catch_except_p = catch_except_p;

load_body->is_entries = ZALLOC_N(union iseq_inline_storage_entry, is_size);

load_body->param.opt_table = ibf_load_param_opt_table(load, param_opt_table_offset, param_opt_num);

load_body->param.keyword = ibf_load_param_keyword(load, param_keyword_offset);

load_body->param.flags.has_kw = (param_flags >> 4) & 1;

#ifdef RB_DEBUG_COUNTER

// callinfo

/*

* call cache fastpath usage

RB_DEBUG_COUNTER(obj_imemo_memo)

RB_DEBUG_COUNTER(obj_imemo_parser_strterm)

RB_DEBUG_COUNTER(obj_imemo_callinfo)

/* ar_table */

RB_DEBUG_COUNTER(artable_hint_hit)

return cond;

}

VALUE rb_debug_counter_reset(VALUE klass);

VALUE rb_debug_counter_show(VALUE klass);

#define RB_DEBUG_COUNTER_INC(type) rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, 1)

#define RB_DEBUG_COUNTER_INC_UNLESS(type, cond) (!rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, !(cond)))

#define RB_DEBUG_COUNTER_INC_IF(type, cond) rb_debug_counter_add(RB_DEBUG_COUNTER_##type, 1, (cond))

#else

#define RB_DEBUG_COUNTER_INC(type) ((void)0)

#define RB_DEBUG_COUNTER_INC_UNLESS(type, cond) (cond)

#define RB_DEBUG_COUNTER_INC_IF(type, cond) (cond)

#endif

void rb_debug_counter_show_results(const char *msg);

{

Check_Type(module, T_MODULE);

using_module_recursive(cref, module);

}

/*! \private */

imemo_type_ids[9] = rb_intern("imemo_ast");

imemo_type_ids[10] = rb_intern("imemo_parser_strterm");

imemo_type_ids[11] = rb_intern("imemo_callinfo");

}

rb_objspace_each_objects(count_imemo_objects_i, (void *)hash);

rb_id_table_free(tbl);

}

static inline void

make_zombie(rb_objspace_t *objspace, VALUE obj, void (*dfree)(void *), void *data)

{

case T_CLASS:

mjit_remove_class_serial(RCLASS_SERIAL(obj));

rb_id_table_free(RCLASS_M_TBL(obj));

if (RCLASS_IV_TBL(obj)) {

st_free_table(RCLASS_IV_TBL(obj));

}

rb_class_detach_subclasses(obj);

RCLASS_EXT(obj)->subclasses = NULL;

}

rb_class_remove_from_module_subclasses(obj);

rb_class_remove_from_super_subclasses(obj);

xfree(RANY(obj)->as.klass.ptr);

case imemo_callinfo:

RB_DEBUG_COUNTER_INC(obj_imemo_callinfo);

break;

default:

/* unreachable */

break;

return;

case imemo_callinfo:

return;

#if VM_CHECK_MODE > 0

default:

VM_UNREACHABLE(gc_mark_imemo);

gc_mark(objspace, RCLASS_SUPER(obj));

}

if (!RCLASS_EXT(obj)) break;

mark_m_tbl(objspace, RCLASS_M_TBL(obj));

mark_tbl_no_pin(objspace, RCLASS_IV_TBL(obj));

mark_const_tbl(objspace, RCLASS_CONST_TBL(obj));

break;

}

if (!RCLASS_EXT(obj)) break;

mark_m_tbl(objspace, RCLASS_CALLABLE_M_TBL(obj));

break;

case T_ARRAY:

case imemo_ast:

rb_ast_update_references((rb_ast_t *)obj);

break;

case imemo_parser_strterm:

case imemo_tmpbuf:

case imemo_callinfo:

}

static enum rb_id_table_iterator_result

update_const_table(VALUE value, void *data)

{

rb_const_entry_t *ce = (rb_const_entry_t *)value;

}

if (!RCLASS_EXT(obj)) break;

update_m_tbl(objspace, RCLASS_M_TBL(obj));

gc_update_tbl_refs(objspace, RCLASS_IV_TBL(obj));

update_class_ext(objspace, RCLASS_EXT(obj));

update_const_tbl(objspace, RCLASS_CONST_TBL(obj));

break;

}

update_class_ext(objspace, RCLASS_EXT(obj));

update_m_tbl(objspace, RCLASS_CALLABLE_M_TBL(obj));

break;

case T_IMEMO:

gc_check_references_for_moved(objspace);

}

rb_clear_constant_cache();

heap_eden->free_pages = NULL;

heap_eden->using_page = NULL;

if (!NIL_P(class_path)) {

APPENDF((BUFF_ARGS, "%s", RSTRING_PTR(class_path)));

}

break;

}

case T_ICLASS:

IMEMO_NAME(ast);

IMEMO_NAME(parser_strterm);

IMEMO_NAME(callinfo);

#undef IMEMO_NAME

default: UNREACHABLE;

}

switch (imemo_type(obj)) {

case imemo_ment: {

const rb_method_entry_t *me = &RANY(obj)->as.imemo.ment;

if (me->def) {

rb_id2name(me->called_id),

rb_method_type_name(me->def->type),

}

else {

APPENDF((BUFF_ARGS, "%s", rb_id2name(me->called_id)));

vm_ci_kwarg(ci) ? "available" : "NULL"));

break;

}

default:

break;

}

int index = hash_table_index(tbl, key);

if (index >= 0) {

return TRUE;

}

else {

(VALUE recv)

(VALUE val)

{

if (val == Qundef) {

CALL_SIMPLE_METHOD();

// attr rb_snum_t sp_inc = sp_inc_of_invokeblock(cd->ci);

// attr rb_snum_t comptime_sp_inc = sp_inc_of_invokeblock(ci);

{

}

VALUE bh = VM_BLOCK_HANDLER_NONE;

(VALUE recv, VALUE obj)

(VALUE val)

{

if (val == Qundef) {

CALL_SIMPLE_METHOD();

(VALUE recv, VALUE obj)

(VALUE val)

{

if (val == Qundef) {

CALL_SIMPLE_METHOD();

(VALUE recv)

(VALUE val)

{

if (val == Qundef) {

CALL_SIMPLE_METHOD();

#endif

struct rb_id_table *const_tbl;

struct rb_id_table *callable_m_tbl;

struct rb_subclass_entry *subclasses;

struct rb_subclass_entry **parent_subclasses;

/**

# define RCLASS_M_TBL(c) (RCLASS(c)->m_tbl)

#endif

#define RCLASS_CALLABLE_M_TBL(c) (RCLASS_EXT(c)->callable_m_tbl)

#define RCLASS_IV_INDEX_TBL(c) (RCLASS_EXT(c)->iv_index_tbl)

#define RCLASS_ORIGIN(c) (RCLASS_EXT(c)->origin_)

#define RCLASS_REFINED_CLASS(c) (RCLASS_EXT(c)->refined_class)

#define IMEMO_FL_USER2 FL_USER6

#define IMEMO_FL_USER3 FL_USER7

#define IMEMO_FL_USER4 FL_USER8

enum imemo_type {

imemo_env = 0,

imemo_ast = 9,

imemo_parser_strterm = 10,

imemo_callinfo = 11,

};

/* CREF (Class REFerence) is defined in method.h */

}

}

static inline bool

imemo_throw_data_p(VALUE imemo)

{

MISSING_NONE = 0x40

};

/* vm_insnhelper.h */

rb_serial_t rb_next_class_serial(void);

VALUE rb_equal_opt(VALUE obj1, VALUE obj2);

VALUE rb_eql_opt(VALUE obj1, VALUE obj2);

MJIT_SYMBOL_EXPORT_BEGIN

MJIT_SYMBOL_EXPORT_END

/* vm_dump.c */

if (!SPECIAL_CONST_P(cds[i].ci)) {

cds[i].ci = (struct rb_callinfo *)rb_gc_location((VALUE)cds[i].ci);

}

}

}

if (FL_TEST(iseq, ISEQ_MARKABLE_ISEQ)) {

struct rb_call_data *cds = (struct rb_call_data *)body->call_data;

for (unsigned int i=0; i<body->ci_size; i++) {

rb_gc_mark_movable((VALUE)cds[i].ci);

}

}

}

}

}

}

if (FL_TEST_RAW(iseq, ISEQ_NOT_LOADED_YET)) {

rb_exc_raise(err);

}

rb_iseq_init_trace(iseq);

return Qtrue;

}

#define METHOD_ENTRY_VISI(me) (rb_method_visibility_t)(((me)->flags & (IMEMO_FL_USER0 | IMEMO_FL_USER1)) >> (IMEMO_FL_USHIFT+0))

#define METHOD_ENTRY_BASIC(me) (int) (((me)->flags & (IMEMO_FL_USER2 )) >> (IMEMO_FL_USHIFT+2))

static inline void

METHOD_ENTRY_VISI_SET(rb_method_entry_t *me, rb_method_visibility_t visi)

VALUE rb_unnamed_parameters(int arity);

#endif /* RUBY_METHOD_H */

#include "internal/warnings.h"

#include "mjit_worker.c"

// Copy ISeq's states so that race condition does not happen on compilation.

static void

}

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

}

}

if (job->is_entries) {

memcpy(job->is_entries, body->is_entries, sizeof(union iseq_inline_storage_entry) * body->is_size);

}

bool disable_inlining;

};

typedef VALUE (*mjit_func_t)(rb_execution_context_t *, rb_control_frame_t *);

RUBY_SYMBOL_EXPORT_BEGIN

// For propagating information needed for lazily pushing a frame.

struct inlined_call_context {

int orig_argc; // ci->orig_argc

};

// Storage to keep compiler's status. This should have information

bool local_stack_p;

// Safely-accessible cache entries copied from main thread.

union iseq_inline_storage_entry *is_entries;

// Mutated optimization levels

struct rb_mjit_compile_info *compile_info;

// If `inlined_iseqs[pos]` is not NULL, `mjit_compile_body` tries to inline ISeq there.

VALUE last_value;

};

static bool

has_valid_method_type(CALL_CACHE cc)

{

}

// Returns true if iseq can use fastpath for setup, otherwise NULL. This becomes true in the same condition

fprintf(f, " return Qundef;\n");

}

static bool

mjit_compile_body(FILE *f, const rb_iseq_t *iseq, struct compile_status *status)

.stack_size_for_pos = (int *)alloca(sizeof(int) * body->iseq_size), \

.inlined_iseqs = compile_root_p ? \

alloca(sizeof(const struct rb_iseq_constant_body *) * body->iseq_size) : NULL, \

.is_entries = (body->is_size > 0) ? \

alloca(sizeof(union iseq_inline_storage_entry) * body->is_size) : NULL, \

.compile_info = compile_root_p ? \

#else

int insn = (int)body->iseq_encoded[pos];

#endif

if (insn == BIN(opt_send_without_block)) { // `compile_inlined_cancel_handler` supports only `opt_send_without_block`

CALL_DATA cd = (CALL_DATA)body->iseq_encoded[pos + 1];

const struct rb_callinfo *ci = cd->ci;

const rb_iseq_t *child_iseq;

status->inlined_iseqs[pos] = child_iseq->body;

if (mjit_opts.verbose >= 1) // print beforehand because ISeq may be GCed during copy job.

INIT_COMPILE_STATUS(child_status, child_iseq->body, false);

child_status.inline_context = (struct inlined_call_context){

.orig_argc = vm_ci_argc(ci),

.param_size = child_iseq->body->param.size,

.local_size = child_iseq->body->local_table_size

};

return false;

fprintf(f, "ALWAYS_INLINE(static VALUE _mjit_inlined_%d(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, const VALUE orig_self, const rb_iseq_t *original_iseq));\n", pos);

struct compile_status status;

INIT_COMPILE_STATUS(status, iseq->body, true);

return false;

if (!status.compile_info->disable_send_cache && !status.compile_info->disable_inlining) {

if (!precompile_inlinable_iseqs(f, iseq, &status))

#define MJIT_TMP_PREFIX "_ruby_mjit_"

// Linked list of struct rb_mjit_unit.

struct rb_mjit_unit_list {

struct list_head head;

typedef struct {

const rb_iseq_t *iseq;

union iseq_inline_storage_entry *is_entries;

bool finish_p;

} mjit_copy_job_t;

// We're lazily copying cache values from main thread because these cache values

// could be different between ones on enqueue timing and ones on dequeue timing.

bool

{

mjit_copy_job_t *job = &mjit_copy_job; // just a short hand

job->finish_p = true; // disable dising this job in mjit_copy_job_handler while it's being modified

CRITICAL_SECTION_FINISH(3, "in mjit_copy_cache_from_main_thread");

job->is_entries = is_entries;

CRITICAL_SECTION_START(3, "in mjit_copy_cache_from_main_thread");

end

def test_tracks_objspace_events

result = EnvUtil.suppress_warning {eval(<<-EOS, nil, __FILE__, __LINE__+1)}

Bug.tracepoint_track_objspace_events {

99

'abc'

_="foobar"

nil

}

EOS

newobj_count, free_count, gc_start_count, gc_end_mark_count, gc_end_sweep_count, *newobjs = *result

assert_equal 'foobar', newobjs[0]

assert_operator free_count, :>=, 0

assert_operator gc_start_count, :==, gc_end_mark_count

assert_operator gc_start_count, :>=, gc_end_sweep_count

end

def test_tracks_objspace_count

stat1 = {}

stat2 = {}

GC.disable

GC.start

GC.stat(stat)

ObjectSpace.count_objects(count)

assert_equal(count[:TOTAL]-count[:FREE], stat[:heap_live_slots])

assert_equal(count[:FREE], stat[:heap_free_slots])

#{fname(param, local)}(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)

{

RB_DEBUG_COUNTER_INC(ccf_iseq_fix);

}

EOS

MAYBE_UNUSED(<%= ope.fetch(:decl) %>) = (<%= ope.fetch(:type) %>)operands[<%= i %>];

% end

% # compiler: Use copied cc to avoid race condition

%

const rb_iseq_t *iseq;

const CALL_INFO ci = cd->ci;

unsigned int argc = vm_ci_argc(ci); // this `argc` variable is for calculating a value's position on stack considering `blockarg`.

% end

if (!(vm_ci_flag(ci) & VM_CALL_TAILCALL) // inlining non-tailcall path

int param_size = iseq->body->param.size;

fprintf(f, "{\n");

}

% # JIT: Invalidate call cache if it requires vm_search_method. This allows to inline some of following things.

fprintf(f, " reg_cfp->pc = original_body_iseq + %d;\n", pos);

fprintf(f, " reg_cfp->sp = vm_base_ptr(reg_cfp) + %d;\n", b->stack_size);

fprintf(f, " goto send_cancel;\n");

fprintf(f, " {\n");

fprintf(f, " struct rb_calling_info calling;\n");

% if insn.name == 'send'

% else

fprintf(f, " calling.block_handler = VM_BLOCK_HANDLER_NONE;\n");

% end

fprintf(f, " calling.argc = %d;\n", vm_ci_argc(ci));

fprintf(f, " calling.recv = stack[%d];\n", b->stack_size - 1 - argc);

fprintf(f, " {\n");

fprintf(f, " VALUE v;\n");

if (iseq->body->catch_except_p) {

fprintf(f, " VM_ENV_FLAGS_SET(ec->cfp->ep, VM_FRAME_FLAG_FINISH);\n");

fprintf(f, " v = vm_exec(ec, TRUE);\n");

% when *send_compatible_opt_insns

% # To avoid cancel, just emit `opt_send_without_block` instead of `opt_*` insn if call cache is populated.

% cd_index = insn.opes.index { |o| o.fetch(:type) == 'CALL_DATA' }

<%= render 'mjit_compile_send', locals: { insn: opt_send_without_block } -%>

<%= render 'mjit_compile_insn', locals: { insn: opt_send_without_block } -%>

break;

rb_serial_t ruby_vm_global_constant_state = 1;

rb_serial_t ruby_vm_class_serial = 1;

static void thread_free(void *ptr);

void

m_core_undef_method(VALUE self, VALUE cbase, VALUE sym)

{

REWIND_CFP({

});

return Qnil;

}

return rb_block_lambda();

}

void

Init_VM(void)

{

#if VMDEBUG

rb_define_singleton_method(rb_cRubyVM, "SDR", sdr, 0);

rb_define_singleton_method(rb_cRubyVM, "NSDR", nsdr, 0);

#else

(void)sdr;

(void)nsdr;

#endif

/* VM bootstrap: phase 2 */

vm->frozen_strings = st_init_table_with_size(&rb_fstring_hash_type, 10000);

rb_objspace_gc_enable(vm->objspace);

}

/* top self */

}

#endif

#endif /* #ifndef MJIT_HEADER */

#include "vm_call_iseq_optimized.inc" /* required from vm_insnhelper.c */

#define CI_EMBED_FLAG 0x01

#define CI_EMBED_ARGC_SHFT (CI_EMBED_TAG_bits)

#define CI_EMBED_FLAG_SHFT (CI_EMBED_TAG_bits + CI_EMBED_ARGC_bits)

#define CI_EMBED_ID_SHFT (CI_EMBED_TAG_bits + CI_EMBED_ARGC_bits + CI_EMBED_FLAG_bits)

vm_ci_packed_p(const struct rb_callinfo *ci)

{

#if USE_EMBED_CI

return 1;

}

else {

return 0;

}

#else

#endif

}

static inline ID

vm_ci_mid(const struct rb_callinfo *ci)

{

}

}

static inline void

vm_ci_dump(const struct rb_callinfo *ci)

{

rp(ci);

}

}

#define vm_ci_new(mid, flag, argc, kwarg) vm_ci_new_(mid, flag, argc, kwarg, __FILE__, __LINE__)

#define vm_ci_new_runtime(mid, flag, argc, kwarg) vm_ci_new_runtime_(mid, flag, argc, kwarg, __FILE__, __LINE__)

vm_ci_new_(ID mid, unsigned int flag, unsigned int argc, const struct rb_callinfo_kwarg *kwarg, const char *file, int line)

{

#if USE_EMBED_CI

if ((mid & ~CI_EMBED_ID_MASK) == 0 &&

(argc & ~CI_EMBED_ARGC_MASK) == 0 &&

kwarg == NULL) {

VALUE embed_ci =

((VALUE)argc << CI_EMBED_ARGC_SHFT) |

((VALUE)flag << CI_EMBED_FLAG_SHFT) |

((VALUE)mid << CI_EMBED_ID_SHFT);

return (const struct rb_callinfo *)embed_ci;

}

#endif

const bool debug = 0;

if (debug) fprintf(stderr, "%s:%d ", file, line);

const struct rb_callinfo *ci = (const struct rb_callinfo *)

rb_imemo_new(imemo_callinfo,

(VALUE)mid,

RB_DEBUG_COUNTER_INC(ci_runtime);

return vm_ci_new_(mid, flag, argc, kwarg, file, line);

}

};

struct rb_execution_context_struct;

#if 1

#define CoreDataFromValue(obj, type) (type*)DATA_PTR(obj)

typedef struct iseq_inline_iv_cache_entry *IVC;

typedef union iseq_inline_storage_entry *ISE;

typedef const struct rb_callinfo *CALL_INFO;

typedef struct rb_call_data *CALL_DATA;

typedef VALUE CDHASH;

}

if (cfp->iseq != 0) {

if (RUBY_VM_IFUNC_P(cfp->iseq)) {

iseq_name = "<ifunc>";

}

char buff[0x100];

if (me) {

fprintf(stderr, " me:\n");

fprintf(stderr, " called_id: %s, type: %s\n", rb_id2name(me->called_id), rb_method_type_name(me->def->type));

fprintf(stderr, " owner class: %s\n", rb_raw_obj_info(buff, 0x100, me->owner));

{

struct rb_calling_info calling = { Qundef, recv, argc, kw_splat, };

const struct rb_callinfo *ci = vm_ci_new_runtime(id, kw_splat ? VM_CALL_KW_SPLAT : 0, argc, NULL);

struct rb_call_data cd = { ci, cc, };

return vm_call0_body(ec, &calling, &cd, argv);

}

vm_call0_cfunc_with_frame(rb_execution_context_t* ec, struct rb_calling_info *calling, struct rb_call_data *cd, const VALUE *argv)

{

const struct rb_callinfo *ci = cd->ci;

VALUE val;

const rb_method_cfunc_t *cfunc = UNALIGNED_MEMBER_PTR(me->def, body.cfunc);

int len = cfunc->argc;

VALUE recv = calling->recv;

vm_call0_body(rb_execution_context_t *ec, struct rb_calling_info *calling, struct rb_call_data *cd, const VALUE *argv)

{

const struct rb_callinfo *ci = cd->ci;

VALUE ret;

calling->block_handler = vm_passed_block_handler(ec);

again:

case VM_METHOD_TYPE_ISEQ:

{

rb_control_frame_t *reg_cfp = ec->cfp;

}

rb_check_arity(calling->argc, 1, 1);

goto success;

case VM_METHOD_TYPE_IVAR:

if (calling->kw_splat &&

}

rb_check_arity(calling->argc, 0, 0);

goto success;

case VM_METHOD_TYPE_BMETHOD:

ret = vm_call_bmethod_body(ec, calling, cd, argv);

case VM_METHOD_TYPE_ZSUPER:

case VM_METHOD_TYPE_REFINED:

{

if (type == VM_METHOD_TYPE_ZSUPER) {

super_class = RCLASS_ORIGIN(super_class);

}

}

super_class = RCLASS_SUPER(super_class);

if (super_class) {

RUBY_VM_CHECK_INTS(ec);

goto again;

}

goto success;

}

case VM_METHOD_TYPE_ALIAS:

goto again;

case VM_METHOD_TYPE_MISSING:

{

argv, MISSING_NOENTRY, calling->kw_splat);

}

case VM_METHOD_TYPE_OPTIMIZED:

case OPTIMIZED_METHOD_TYPE_SEND:

ret = send_internal(calling->argc, argv, calling->recv, calling->kw_splat ? CALL_FCALL_KW : CALL_FCALL);

goto success;

goto success;

}

default:

}

break;

case VM_METHOD_TYPE_UNDEF:

break;

}

return Qundef;

success:

VALUE recv;

ID mid;

rb_execution_context_t *ec;

unsigned int respond: 1;

unsigned int respond_to_missing: 1;

int argc;

struct rescue_funcall_args *args = (void *)v;

return call_method_entry(args->ec, args->defined_class,

args->recv, idMethodMissing,

}

static VALUE

check_funcall_missing(rb_execution_context_t *ec, VALUE klass, VALUE recv, ID mid, int argc, const VALUE *argv, int respond, VALUE def, int kw_splat)

{

struct rescue_funcall_args args;

VALUE ret = Qundef;

ret = basic_obj_respond_to_missing(ec, klass, recv,

args.respond = respond > 0;

args.respond_to_missing = (ret != Qundef);

ret = def;

VALUE argbuf, *new_args = ALLOCV_N(VALUE, argbuf, argc+1);

new_args[0] = ID2SYM(mid);

ec->method_missing_reason = MISSING_NOENTRY;

args.ec = ec;

args.recv = recv;

args.mid = mid;

args.argc = argc + 1;

args.argv = new_args;

}

static int

{

return TRUE;

}

else {

MJIT_FUNC_EXPORTED void

vm_check_canary(const rb_execution_context_t *ec, VALUE *sp)

{

const struct rb_control_frame_struct *reg_cfp = ec->cfp;

const struct rb_iseq_struct *iseq;

return 0;

}

static inline VALUE

{

#if OPT_IC_FOR_IVAR

VALUE val = Qundef;

// frozen?

}

else if (LIKELY(is_attr ?

RB_DEBUG_COUNTER_INC_UNLESS(ivar_get_ic_miss_serial,

ic->ic_serial == RCLASS_SERIAL(RBASIC(obj)->klass)))) {

RB_DEBUG_COUNTER_INC(ivar_get_ic_hit);

ic->ic_serial = RCLASS_SERIAL(RBASIC(obj)->klass);

}

else { /* call_info */

}

if (index < numiv) {

}

static inline VALUE

{

#if OPT_IC_FOR_IVAR

rb_check_frozen_internal(obj);

if (LIKELY(

(!is_attr && RB_DEBUG_COUNTER_INC_UNLESS(ivar_set_ic_miss_serial, ic->ic_serial == RCLASS_SERIAL(klass))) ||

VALUE *ptr = ROBJECT_IVPTR(obj);

if (RB_DEBUG_COUNTER_INC_UNLESS(ivar_set_ic_miss_oorange, index < ROBJECT_NUMIV(obj))) {

RB_OBJ_WRITE(obj, &ptr[index], val);

rb_raise(rb_eArgError, "too many instance variables");

}

else {

}

}

/* fall through */

static VALUE vm_call_general(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling, struct rb_call_data *cd);

{

}

}

}

{

}

{

}

}

}

}

}

static void

{

#if OPT_INLINE_METHOD_CACHE

}

#endif

}

static void

{

VALUE klass = CLASS_OF(recv);

VM_ASSERT(klass != Qfalse);

VM_ASSERT(RBASIC_CLASS(klass) == 0 || rb_obj_is_kind_of(klass, rb_cClass));

}

static inline int

}

static inline int

{

}

static VALUE

{

return recv == obj ? Qtrue : Qfalse;

}

inline

#endif

VALUE

{

switch (comparable_by_identity(recv, obj)) {

case 1:

}

fallback:

}

static

}

fallback:

}

#undef BUILTIN_CLASS_P

#undef EQ_UNREDEFINED_P

rb_gc_register_mark_object((VALUE)ci);

}

}

VALUE

rb_eql_opt(VALUE obj1, VALUE obj2)

{

return opt_eql_func(obj1, obj2, &cd);

}

{

RB_DEBUG_COUNTER_INC(ccf_iseq_setup_0start);

int param = iseq->body->param.size;

int local = iseq->body->local_table_size;

}

MJIT_STATIC bool

struct rb_calling_info *calling,

struct rb_call_data *cd)

{

const int lead_num = iseq->body->param.lead_num;

const int opt = calling->argc - lead_num;

const int opt_num = iseq->body->param.opt_num;

}

#endif

}

static VALUE

struct rb_calling_info *calling,

struct rb_call_data *cd)

{

const int lead_num = iseq->body->param.lead_num;

const int opt = calling->argc - lead_num;

const int opt_pc = (int)iseq->body->param.opt_table[opt];

struct rb_call_data *cd)

{

const struct rb_callinfo *ci = cd->ci;

VM_ASSERT(vm_ci_flag(ci) & VM_CALL_KWARG);

RB_DEBUG_COUNTER_INC(ccf_iseq_kw1);

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

const struct rb_callinfo_kwarg *kw_arg = vm_ci_kwarg(ci);

const int ci_kw_len = kw_arg->keyword_len;

int param = iseq->body->param.size;

int local = iseq->body->local_table_size;

}

static VALUE

struct rb_call_data *cd)

{

const struct rb_callinfo *MAYBE_UNUSED(ci) = cd->ci;

VM_ASSERT((vm_ci_flag(ci) & VM_CALL_KWARG) == 0);

RB_DEBUG_COUNTER_INC(ccf_iseq_kw2);

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

VALUE * const argv = cfp->sp - calling->argc;

VALUE * const klocals = argv + kw_param->bits_start - kw_param->num;

int param = iseq->body->param.size;

int local = iseq->body->local_table_size;

}

static inline int

const rb_iseq_t *iseq, VALUE *argv, int param_size, int local_size)

{

const struct rb_callinfo *ci = cd->ci;

if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_KW_SPLAT))) {

if (LIKELY(rb_simple_iseq_p(iseq))) {

argument_arity_error(ec, iseq, calling->argc, iseq->body->param.lead_num, iseq->body->param.lead_num);

}

return 0;

}

else if (rb_iseq_only_optparam_p(iseq)) {

if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {

CC_SET_FASTPATH(cc, vm_call_iseq_setup_normal_opt_start,

!IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&

}

else {

CC_SET_FASTPATH(cc, vm_call_iseq_setup_tailcall_opt_start,

!IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&

}

/* initialize opt vars for self-references */

args_setup_kw_parameters(ec, iseq, ci_kws, ci_kw_len, ci_keywords, klocals);

CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_kwarg,

return 0;

}

if (klocals[kw_param->num] == INT2FIX(0)) {

/* copy from default_values */

CC_SET_FASTPATH(cc, vm_call_iseq_setup_kwparm_nokwarg,

}

return 0;

{

RB_DEBUG_COUNTER_INC(ccf_iseq_setup);

const int param_size = iseq->body->param.size;

const int local_size = iseq->body->local_table_size;

return vm_call_iseq_setup_2(ec, cfp, calling, cd, opt_pc, param_size, local_size);

}

int opt_pc, int param_size, int local_size)

{

const struct rb_callinfo *ci = cd->ci;

if (LIKELY(!(vm_ci_flag(ci) & VM_CALL_TAILCALL))) {

}

else {

return vm_call_iseq_setup_tailcall(ec, cfp, calling, cd, opt_pc);

vm_call_iseq_setup_tailcall(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, struct rb_call_data *cd,

int opt_pc)

{

unsigned int i;

VALUE *argv = cfp->sp - calling->argc;

const rb_iseq_t *iseq = def_iseq_ptr(me->def);

VALUE *src_argv = argv;

VALUE *sp_orig, *sp;

vm_call_cfunc_with_frame(rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, struct rb_calling_info *calling, struct rb_call_data *cd)

{

const struct rb_callinfo *ci = cd->ci;

VALUE val;

const rb_method_cfunc_t *cfunc = vm_method_cfunc_entry(me);

int len = cfunc->argc;

static VALUE

vm_call_ivar(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)

{

RB_DEBUG_COUNTER_INC(ccf_ivar);

cfp->sp -= 1;

}

static VALUE

vm_call_attrset(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)

{

RB_DEBUG_COUNTER_INC(ccf_attrset);

VALUE val = *(cfp->sp - 1);

cfp->sp -= 2;

}

static inline VALUE

{

rb_proc_t *proc;

VALUE val;

/* control block frame */

return val;

}

return vm_call_bmethod_body(ec, calling, cd, argv);

}

static enum method_missing_reason

ci_missing_reason(const struct rb_callinfo *ci)

{

int i;

VALUE sym;

ID mid;

struct rb_call_data cd;

i = calling->argc - 1;

rb_raise(rb_eArgError, "no method name given");

}

sym = TOPN(i);

if (!(mid = rb_check_id(&sym))) {

VALUE exc =

rb_make_no_method_exception(rb_eNoMethodError, 0, calling->recv,

rb_long2int(calling->argc), &TOPN(i),

rb_exc_raise(exc);

}

TOPN(i) = rb_str_intern(sym);

mid = idMethodMissing;

}

else {

/* shift arguments */

DEC_SP(1);

}

unsigned int new_flag = VM_CALL_FCALL | VM_CALL_OPT_SEND | (calling->kw_splat ? VM_CALL_KW_SPLAT : 0);

return vm_call_method(ec, reg_cfp, calling, (CALL_DATA)&cd);

}

}

else {

calling->recv = rb_vm_bh_to_procval(ec, block_handler);

return vm_call_general(ec, reg_cfp, calling, cd);

}

}

static VALUE

{

RB_DEBUG_COUNTER_INC(ccf_method_missing);

VALUE *argv = STACK_ADDR_FROM_TOP(calling->argc);

unsigned int argc;

CALLER_SETUP_ARG(reg_cfp, calling, orig_ci);

unsigned int flag = VM_CALL_FCALL | VM_CALL_OPT_SEND | (calling->kw_splat ? VM_CALL_KW_SPLAT : 0);

cd.ci = vm_ci_new_runtime(idMethodMissing, flag, argc, vm_ci_kwarg(orig_ci));

calling->argc = argc;

argv[0] = ID2SYM(vm_ci_mid(orig_ci));

INC_SP(1);

return vm_call_method(ec, reg_cfp, calling, &cd);

}

static const rb_callable_method_entry_t *refined_method_callable_without_refinement(const rb_callable_method_entry_t *me);

static VALUE

vm_call_zsuper(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, struct rb_call_data *cd, VALUE klass)

{

klass = RCLASS_SUPER(klass);

return vm_call_method_nome(ec, cfp, calling, cd);

}

}

}

static inline VALUE

return cfp;

}

static const rb_callable_method_entry_t *

refined_method_callable_without_refinement(const rb_callable_method_entry_t *me)

{

return cme;

}

{

const rb_cref_t *cref = vm_get_cref(cfp->ep);

for (; cref; cref = CREF_NEXT(cref)) {

if (NIL_P(refinement)) continue;

const rb_callable_method_entry_t *const ref_me =

rb_callable_method_entry(refinement, mid);

if (ref_me) {

const rb_control_frame_t *top_cfp = current_method_entry(ec, cfp);

const rb_callable_method_entry_t *top_me = rb_vm_frame_method_entry(top_cfp);

if (top_me && rb_method_definition_eq(ref_me->def, top_me->def)) {

continue;

}

}

}

if (ref_me->def->type != VM_METHOD_TYPE_REFINED) {

}

}

else {

}

}

}

else {

}

}

static VALUE

vm_call_method_each_type(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)

{

const struct rb_callinfo *ci = cd->ci;

case VM_METHOD_TYPE_ISEQ:

CC_SET_FASTPATH(cc, vm_call_iseq_setup, TRUE);

return vm_call_iseq_setup(ec, cfp, calling, cd);

CALLER_REMOVE_EMPTY_KW_SPLAT(cfp, calling, ci);

rb_check_arity(calling->argc, 1, 1);

return vm_call_attrset(ec, cfp, calling, cd);

case VM_METHOD_TYPE_IVAR:

CALLER_SETUP_ARG(cfp, calling, ci);

CALLER_REMOVE_EMPTY_KW_SPLAT(cfp, calling, ci);

rb_check_arity(calling->argc, 0, 0);

return vm_call_ivar(ec, cfp, calling, cd);

case VM_METHOD_TYPE_MISSING:

CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);

return vm_call_method_missing(ec, cfp, calling, cd);

return vm_call_bmethod(ec, cfp, calling, cd);

case VM_METHOD_TYPE_ALIAS:

case VM_METHOD_TYPE_OPTIMIZED:

case OPTIMIZED_METHOD_TYPE_SEND:

CC_SET_FASTPATH(cc, vm_call_opt_send, TRUE);

return vm_call_opt_send(ec, cfp, calling, cd);

return vm_call_opt_block_call(ec, cfp, calling, cd);

default:

rb_bug("vm_call_method: unsupported optimized method type (%d)",

}

case VM_METHOD_TYPE_UNDEF:

break;

case VM_METHOD_TYPE_ZSUPER:

case VM_METHOD_TYPE_REFINED:

}

}

NORETURN(static void vm_raise_method_missing(rb_execution_context_t *ec, int argc, const VALUE *argv, VALUE obj, int call_status));

{

/* method missing */

const struct rb_callinfo *ci = cd->ci;

const int stat = ci_missing_reason(ci);

if (vm_ci_mid(ci) == idMethodMissing) {

vm_raise_method_missing(ec, calling->argc, argv, calling->recv, stat);

}

else {

}

}

vm_call_method(rb_execution_context_t *ec, rb_control_frame_t *cfp, struct rb_calling_info *calling, struct rb_call_data *cd)

{

const struct rb_callinfo *ci = cd->ci;

case METHOD_VISI_PUBLIC: /* likely */

return vm_call_method_each_type(ec, cfp, calling, cd);

enum method_missing_reason stat = MISSING_PRIVATE;

if (vm_ci_flag(ci) & VM_CALL_VCALL) stat |= MISSING_VCALL;

CC_SET_FASTPATH(cc, vm_call_method_missing, TRUE);

return vm_call_method_missing(ec, cfp, calling, cd);

}

case METHOD_VISI_PROTECTED:

if (!(vm_ci_flag(ci) & VM_CALL_OPT_SEND)) {

return vm_call_method_missing(ec, cfp, calling, cd);

}

else {

/* caching method info to dummy cc */

}

}

return vm_call_method_each_type(ec, cfp, calling, cd);

RB_DEBUG_COUNTER_INC(ccf_super_method);

/* this check is required to distinguish with other functions. */

return vm_call_method(ec, reg_cfp, calling, cd);

}

if (!klass) {

/* bound instance method of module */

}

else {

}

}

struct rb_call_data *cd,

VALUE recv)

{

}

static void

struct rb_call_data *cd,

VALUE recv))

{

VALUE val;

int argc = vm_ci_argc(ci);

VALUE recv = TOPN(argc);

struct rb_calling_info calling;

calling.argc = argc;

method_explorer(GET_CFP(), cd, recv);

if (val != Qundef) {

return val; /* CFUNC normal return */

}

static VALUE

{

if (val != Qundef) {

return RTEST(val) ? Qfalse : Qtrue;

VALUE rb_false(VALUE obj);

static VALUE

{

if (recv == Qnil &&

BASIC_OP_UNREDEFINED_P(BOP_NIL_P, NIL_REDEFINED_OP_FLAG)) {

return Qtrue;

}

return Qfalse;

}

else {

}

static VALUE

{

return RTEST(recv) ? Qfalse : Qtrue;

}

else {

*/

static inline void

{

if (LIKELY(enabled)) {

}

}

#define GET_BLOCK_HANDLER() (GET_LEP()[VM_ENV_DATA_INDEX_SPECVAL])

/**********************************************************/

/* If this returns true, an optimized function returned by `vm_call_iseq_setup_func`

can be used as a fastpath. */

static bool

{

return !IS_ARGS_SPLAT(ci) && !IS_ARGS_KEYWORD(ci) &&

}

#endif /* RUBY_INSNHELPER_H */

#define METHOD_DEBUG 0

static int vm_redefinition_check_flag(VALUE klass);

static void rb_vm_check_redefinition_opt_method(const rb_method_entry_t *me, VALUE klass);

#define singleton_undefined idSingleton_method_undefined

#define attached id__attached__

#define ruby_running (GET_VM()->running)

/* int ruby_running = 0; */

{

}

}

}

}

void

INC_GLOBAL_CONSTANT_STATE();

}

{

}

}

}

VALUE

rb_method_cfunc_t opt;

opt.func = func;

opt.argc = argc;

}

else {

rb_define_notimplement_method_id(klass, mid, visi);

xfree(def);

}

else {

if (METHOD_DEBUG) fprintf(stderr, "-%p-%s:%d->%d,%d->%d (dec)\n", (void *)def, rb_id2name(def->original_id),

alias_count, def->alias_count, complemented_count, def->complemented_count);

static inline rb_method_entry_t *search_method(VALUE klass, ID id, VALUE *defined_class_ptr);

extern int rb_method_definition_eq(const rb_method_definition_t *d1, const rb_method_definition_t *d2);

static VALUE

(*call_cfunc_invoker_func(int argc))(VALUE recv, int argc, const VALUE *, VALUE (*func)(ANYARGS))

{

rb_method_entry_clone(const rb_method_entry_t *src_me)

{

rb_method_entry_t *me = rb_method_entry_alloc(src_me->called_id, src_me->owner, src_me->defined_class,

METHOD_ENTRY_FLAGS_COPY(me, src_me);

return me;

}

}

}

void

rb_add_refined_method_entry(VALUE refined_class, ID mid)

{

if (me) {

make_method_entry_refined(refined_class, me);

}

else {

rb_add_method(refined_class, mid, VM_METHOD_TYPE_REFINED, 0, METHOD_VISI_PUBLIC);

if (def == NULL) def = rb_method_definition_create(type, original_id);

rb_method_definition_set(me, def, opts);

/* check mid */

if (klass == rb_cObject) {

return 0;

}

static inline rb_method_entry_t*

search_method(VALUE klass, ID id, VALUE *defined_class_ptr)

{

rb_method_entry_t *me;

for (; klass; klass = RCLASS_SUPER(klass)) {

RB_DEBUG_COUNTER_INC(mc_search_super);

}

return me;

}

{

}

{

}

}

}

{

}

}

{

}

static const rb_callable_method_entry_t *

{

}

else {

}

return cme;

}

MJIT_FUNC_EXPORTED const rb_callable_method_entry_t *

{

}

static const rb_method_entry_t *resolve_refined_method(VALUE refinements, const rb_method_entry_t *me, VALUE *defined_class_ptr);

static const rb_method_entry_t *

method_entry_resolve_refinement(VALUE klass, ID id, int with_refinement, VALUE *defined_class_ptr)

{

if (me) {

if (me->def->type == VM_METHOD_TYPE_REFINED) {

MJIT_FUNC_EXPORTED const rb_callable_method_entry_t *

rb_callable_method_entry_with_refinements(VALUE klass, ID id, VALUE *defined_class_ptr)

{

}

const rb_method_entry_t *

{

VALUE defined_class, *dcp = defined_class_ptr ? defined_class_ptr : &defined_class;

const rb_method_entry_t *me = method_entry_resolve_refinement(klass, id, FALSE, dcp);

}

static const rb_method_entry_t *

refinement = find_refinement(refinements, me->owner);

if (!NIL_P(refinement)) {

if (tmp_me && tmp_me->def->type != VM_METHOD_TYPE_REFINED) {

return tmp_me;

return 0;

}

}

return me;

}

klass, ID2SYM(mid));

}

rb_id_table_delete(RCLASS_M_TBL(klass), mid);

rb_vm_check_redefinition_opt_method(me, klass);

if (me->def->type == VM_METHOD_TYPE_REFINED) {

rb_add_refined_method_entry(klass, mid);

VALUE origin_class = RCLASS_ORIGIN(klass);

me = search_method(origin_class, name, &defined_class);

if (!me && RB_TYPE_P(klass, T_MODULE)) {

me = search_method(rb_cObject, name, &defined_class);

}

if (me->def->type == VM_METHOD_TYPE_REFINED && me->def->body.refined.orig_me) {

METHOD_ENTRY_VISI_SET((rb_method_entry_t *)me->def->body.refined.orig_me, visi);

}

}

else {

rb_add_method(klass, name, VM_METHOD_TYPE_ZSUPER, 0, visi);

me = rb_method_entry_without_refinements(klass, id, NULL);

}

((METHOD_ENTRY_VISI(me) == METHOD_VISI_PRIVATE) ||

((ex & BOUND_RESPONDS) && (METHOD_ENTRY_VISI(me) == METHOD_VISI_PROTECTED)))) {

return 0;

again:

orig_me = search_method(klass, original_name, &defined_class);

if (orig_me && orig_me->def->type == VM_METHOD_TYPE_REFINED) {

orig_me = rb_resolve_refined_method(Qnil, orig_me);

}

!me->def->body.iseq.iseqptr->body->param.flags.has_kw &&

!me->def->body.iseq.iseqptr->body->param.flags.has_kwrest) {

me->def->body.iseq.iseqptr->body->param.flags.ruby2_keywords = 1;

}

else {

rb_warn("Skipping set of ruby2_keywords flag for %s (method accepts keywords or method does not accept argument splat)", rb_id2name(name));

!iseq->body->param.flags.has_kw &&

!iseq->body->param.flags.has_kwrest) {

iseq->body->param.flags.ruby2_keywords = 1;

}

else {

rb_warn("Skipping set of ruby2_keywords flag for %s (method accepts keywords or method does not accept argument splat)", rb_id2name(name));

int

rb_method_basic_definition_p(VALUE klass, ID id)

{

if (!klass) return TRUE; /* hidden object cannot be overridden */

}

#ifdef __GNUC__

#pragma pop_macro("rb_method_basic_definition_p")

static VALUE

call_method_entry(rb_execution_context_t *ec, VALUE defined_class, VALUE obj, ID id,

{

VALUE passed_block_handler = vm_passed_block_handler(ec);

VALUE result = rb_vm_call_kw(ec, obj, id, argc, argv, cme, kw_splat);

vm_passed_block_handler_set(ec, passed_block_handler);

{

VALUE defined_class, args[2];

const ID rtmid = idRespond_to_missing;

args[0] = mid;

args[1] = priv;

}

static inline int

{

VALUE defined_class;

const ID resid = idRespond_to;

return -1;

}

else {

args[0] = ID2SYM(id);

args[1] = Qtrue;

if (priv) {

if (argc > 2) {

rb_raise(rb_eArgError,

"respond_to? must accept 1 or 2 arguments (requires %d)",

argc = 2;

}

else if (!NIL_P(ruby_verbose)) {

rb_warn("%"PRIsVALUE"%c""respond_to?(:%"PRIsVALUE") uses"

" the deprecated method signature, which takes one parameter",

(FL_TEST(klass, FL_SINGLETON) ? obj : klass),

}

}

}

return RTEST(result);

}

}

void

Init_Method(void)

{

}

void