kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* insns.def (send, invokesuper, invokeblock, opt_*), vm_core.h:

Browse source 
use only a `ci' (rb_call_info_t) parameter instead of using
  parameters such as `op_id', 'op_argc', `blockiseq' and flag.
  These information are stored in rb_call_info_t at the compile
  time.
  This technique simplifies parameter passings at related
  function calls (~10% speedups for simple mehtod invocation at
  my machine).
  `rb_call_info_t' also has new function pointer variable `call'.
  This `call' variable enables to customize method (block)
  invocation process for each place. However, it always call
  `vm_call_general()' at this changes.
  `rb_call_info_t' also has temporary variables for method
  (block) invocation.
* vm_core.h, compile.c, insns.def: introduce VM_CALL_ARGS_SKIP_SETUP
  VM_CALL macro.  This flag indicates that this call can skip
  caller_setup (block arg and splat arg).
* compile.c: catch up above changes.
* iseq.c: catch up above changes (especially for TS_CALLINFO).
* tool/instruction.rb: catch up above chagnes.
* vm_insnhelper.c, vm_insnhelper.h: ditto. Macros and functions
  parameters are changed.
* vm_eval.c (vm_call0): ditto (it will be rewriten soon).



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@37180 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ko1 2012-10-14 16:59:05 +00:00
parent e8c234577f
commit cbd597e9bc
9 changed files with 671 additions and 550 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
ChangeLog
View file

@ -1,3 +1,35 @@
Mon Oct 15 01:38:06 2012 Koichi Sasada <ko1@atdot.net>
* insns.def (send, invokesuper, invokeblock, opt_*), vm_core.h:
use only a `ci' (rb_call_info_t) parameter instead of using
parameters such as `op_id', 'op_argc', `blockiseq' and flag.
These information are stored in rb_call_info_t at the compile
time.
This technique simplifies parameter passings at related
function calls (~10% speedups for simple mehtod invocation at
my machine).
`rb_call_info_t' also has new function pointer variable `call'.
This `call' variable enables to customize method (block)
invocation process for each place. However, it always call
`vm_call_general()' at this changes.
`rb_call_info_t' also has temporary variables for method
(block) invocation.
* vm_core.h, compile.c, insns.def: introduce VM_CALL_ARGS_SKIP_SETUP
VM_CALL macro. This flag indicates that this call can skip
caller_setup (block arg and splat arg).
* compile.c: catch up above changes.
* iseq.c: catch up above changes (especially for TS_CALLINFO).
* tool/instruction.rb: catch up above chagnes.
* vm_insnhelper.c, vm_insnhelper.h: ditto. Macros and functions
parameters are changed.
* vm_eval.c (vm_call0): ditto (it will be rewriten soon).
Sun Oct 14 12:30:44 2012 Nobuyoshi Nakada <nobu@ruby-lang.org>
* ruby.c (rb_f_sub, rb_f_gsub): pass the given block.

181
compile.c
View file

@ -935,20 +935,36 @@ new_insn_body(rb_iseq_t *iseq, int line_no, int insn_id, int argc, ...)
return new_insn_core(iseq, line_no, insn_id, argc, operands);
}
static INSN *
new_insn_send(rb_iseq_t *iseq, int line_no,
VALUE id, VALUE argc, VALUE block, VALUE flag)
static rb_call_info_t *
new_callinfo(rb_iseq_t *iseq, ID mid, int argc, VALUE block, unsigned long flag)
{
INSN *iobj = 0;
VALUE *operands =
(VALUE *)compile_data_alloc(iseq, sizeof(VALUE) * 5);
operands[0] = id;
operands[1] = argc;
operands[2] = block;
operands[3] = flag;
operands[4] = INT2FIX(iseq->callinfo_size++);
iobj = new_insn_core(iseq, line_no, BIN(send), 5, operands);
return iobj;
rb_call_info_t *ci = (rb_call_info_t *)compile_data_alloc(iseq, sizeof(rb_call_info_t));
ci->mid = mid;
ci->flag = flag;
ci->orig_argc = argc;
if (block) {
GetISeqPtr(block, ci->blockiseq);
}
else {
ci->blockiseq = 0;
if (!(ci->flag & (VM_CALL_ARGS_BLOCKARG_BIT | VM_CALL_ARGS_SPLAT_BIT))) {
ci->flag |= VM_CALL_ARGS_SKIP_SETUP;
}
}
ci->vmstat = 0;
ci->argc = iseq->callinfo_size++; /* index of callinfo in this iseq */
return ci;
}
static INSN *
new_insn_send(rb_iseq_t *iseq, int line_no, VALUE id, VALUE argc, VALUE block, VALUE flag)
{
VALUE *operands = (VALUE *)compile_data_alloc(iseq, sizeof(VALUE) * 1);
operands[0] = (VALUE)new_callinfo(iseq, SYM2ID(id), FIX2INT(argc), block, FIX2INT(flag));
return new_insn_core(iseq, line_no, BIN(send), 1, operands);
}
static VALUE
@ -1399,7 +1415,7 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
iseq->ic_entries = ALLOC_N(struct iseq_inline_cache_entry, iseq->ic_size);
MEMZERO(iseq->ic_entries, struct iseq_inline_cache_entry, iseq->ic_size);
iseq->callinfo_entries = ALLOC_N(rb_call_info_t, iseq->callinfo_size);
MEMZERO(iseq->callinfo_entries, rb_call_info_t, iseq->callinfo_size);
/* MEMZERO(iseq->callinfo_entries, rb_call_info_t, iseq->callinfo_size); */
list = FIRST_ELEMENT(anchor);
k = pos = sp = 0;
@ -1504,10 +1520,12 @@ iseq_set_sequence(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
}
case TS_CALLINFO: /* call info */
{
int ci_index = FIX2INT(operands[j]);
CALL_INFO ci = &iseq->callinfo_entries[ci_index];
if (UNLIKELY(ci_index >= iseq->callinfo_size)) {
rb_bug("iseq_set_sequence: ci_index overflow: index: %d, size: %d", ci_index, iseq->callinfo_size);
rb_call_info_t *base_ci = (rb_call_info_t *)operands[j];
rb_call_info_t *ci = &iseq->callinfo_entries[base_ci->argc];
*ci = *base_ci;
if (UNLIKELY(base_ci->argc >= iseq->callinfo_size)) {
rb_bug("iseq_set_sequence: ci_index overflow: index: %d, size: %d", base_ci->argc, iseq->callinfo_size);
}
generated_iseq[pos + 1 + j] = (VALUE)ci;
break;
@ -1847,10 +1865,11 @@ iseq_peephole_optimize(rb_iseq_t *iseq, LINK_ELEMENT *list, const int do_tailcal
*/
INSN *piobj = (INSN *)get_prev_insn((INSN *)list);
if (piobj->insn_id == BIN(send) &&
piobj->operands[2] == 0 /* block */
) {
piobj->operands[3] = FIXNUM_OR(piobj->operands[3], VM_CALL_TAILCALL_BIT);
if (piobj->insn_id == BIN(send)) {
rb_call_info_t *ci = (rb_call_info_t *)piobj->operands[0];
if (ci->blockiseq == 0) {
ci->flag |= VM_CALL_TAILCALL_BIT;
}
}
}
return COMPILE_OK;
@ -1859,18 +1878,18 @@ iseq_peephole_optimize(rb_iseq_t *iseq, LINK_ELEMENT *list, const int do_tailcal
static int
insn_set_specialized_instruction(rb_iseq_t *iseq, INSN *iobj, int insn_id)
{
int i, old_opsize = iobj->operand_size;
int old_opsize = iobj->operand_size;
iobj->insn_id = insn_id;
iobj->operand_size = insn_len(insn_id) - 1;
/* printf("iobj->operand_size: %d\n", iobj->operand_size); */
if (iobj->operand_size > old_opsize) {
iobj->operands = (VALUE *)compile_data_alloc(iseq, iobj->operand_size);
VALUE *old_operands = iobj->operands;
if (insn_id != BIN(opt_neq)) {
rb_bug("insn_set_specialized_instruction: unknown insn: %d", insn_id);
}
for (i=0; i<iobj->operand_size; i++) {
iobj->operands[i] = INT2FIX(iseq->callinfo_size++);
iobj->operands = (VALUE *)compile_data_alloc(iseq, iobj->operand_size * sizeof(VALUE));
iobj->operands[0] = old_operands[0];
iobj->operands[1] = (VALUE)new_callinfo(iseq, idEq, 1, 0, 0);
}
return COMPILE_OK;
@ -1880,17 +1899,13 @@ static int
iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
{
if (iobj->insn_id == BIN(send)) {
ID mid = SYM2ID(OPERAND_AT(iobj, 0));
int argc = FIX2INT(OPERAND_AT(iobj, 1));
VALUE block = OPERAND_AT(iobj, 2);
VALUE flag = OPERAND_AT(iobj, 3);
rb_call_info_t *ci = (rb_call_info_t *)OPERAND_AT(iobj, 0);
#define SP_INSN(opt) insn_set_specialized_instruction(iseq, iobj, BIN(opt_##opt))
if (block == 0 && flag == INT2FIX(0)) {
switch (argc) {
if (ci->blockiseq == 0 && (ci->flag & ~VM_CALL_ARGS_SKIP_SETUP) == 0) {
switch (ci->orig_argc) {
case 0:
switch (mid) {
switch (ci->mid) {
case idLength: SP_INSN(length); break;
case idSize: SP_INSN(size); break;
case idEmptyP: SP_INSN(empty_p);break;
@ -1899,7 +1914,7 @@ iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
}
break;
case 1:
switch (mid) {
switch (ci->mid) {
case idPLUS: SP_INSN(plus); break;
case idMINUS: SP_INSN(minus); break;
case idMULT: SP_INSN(mult); break;
@ -1918,8 +1933,9 @@ iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
}
}
}
return COMPILE_OK;
#undef SP_INSN
return COMPILE_OK;
}
static int
@ -2502,15 +2518,16 @@ compile_massign_lhs(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE *node)
switch (nd_type(node)) {
case NODE_ATTRASGN: {
INSN *iobj;
rb_call_info_t *ci;
VALUE dupidx;
COMPILE_POPED(ret, "masgn lhs (NODE_ATTRASGN)", node);
POP_ELEMENT(ret); /* pop pop insn */
iobj = (INSN *)POP_ELEMENT(ret); /* pop send insn */
dupidx = iobj->operands[1];
dupidx = FIXNUM_INC(dupidx, 1);
iobj->operands[1] = dupidx;
ci = (rb_call_info_t *)iobj->operands[0];
ci->orig_argc += 1;
dupidx = INT2FIX(ci->orig_argc);
ADD_INSN1(ret, nd_line(node), topn, dupidx);
ADD_ELEM(ret, (LINK_ELEMENT *)iobj);
@ -4355,11 +4372,10 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
}
/* dummy receiver */
ADD_INSN1(ret, nd_line(node), putobject,
nd_type(node) == NODE_ZSUPER ? Qfalse : Qtrue);
ADD_INSN1(ret, nd_line(node), putobject, nd_type(node) == NODE_ZSUPER ? Qfalse : Qtrue);
ADD_SEQ(ret, args);
ADD_INSN3(ret, nd_line(node), invokesuper,
argc, parent_block, LONG2FIX(flag));
ADD_INSN1(ret, nd_line(node), invokesuper, new_callinfo(iseq, 0, FIX2INT(argc), parent_block,
flag | VM_CALL_SUPER_BIT | VM_CALL_FCALL_BIT));
if (poped) {
ADD_INSN(ret, nd_line(node), pop);
@ -4468,7 +4484,7 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
}
ADD_SEQ(ret, args);
ADD_INSN2(ret, nd_line(node), invokeblock, argc, LONG2FIX(flag));
ADD_INSN1(ret, nd_line(node), invokeblock, new_callinfo(iseq, 0, FIX2INT(argc), 0, flag));
if (poped) {
ADD_INSN(ret, nd_line(node), pop);
@ -5225,7 +5241,7 @@ insn_data_to_s_detail(INSN *iobj)
{
rb_iseq_t *iseq = (rb_iseq_t *)OPERAND_AT(iobj, j);
VALUE val = Qnil;
if (iseq) {
if (0 && iseq) { /* TODO: invalidate now */
val = iseq->self;
}
rb_str_concat(str, rb_inspect(val));
@ -5234,8 +5250,11 @@ insn_data_to_s_detail(INSN *iobj)
case TS_LINDEX:
case TS_NUM: /* ulong */
case TS_VALUE: /* VALUE */
rb_str_concat(str, rb_inspect(OPERAND_AT(iobj, j)));
{
VALUE v = OPERAND_AT(iobj, j);
rb_str_concat(str, rb_inspect(v));
break;
}
case TS_ID: /* ID */
rb_str_concat(str, rb_inspect(OPERAND_AT(iobj, j)));
break;
@ -5244,13 +5263,20 @@ insn_data_to_s_detail(INSN *iobj)
struct rb_global_entry *entry = (struct rb_global_entry *)
(OPERAND_AT(iobj, j) & (~1));
rb_str_cat2(str, rb_id2name(entry->id));
break;
}
case TS_IC: /* inline cache */
rb_str_catf(str, "<ic:%d>", FIX2INT(OPERAND_AT(iobj, j)));
break;
case TS_CALLINFO: /* call info */
rb_str_catf(str, "<callinfo:%d>", FIX2INT(OPERAND_AT(iobj, j)));
{
rb_call_info_t *ci = (rb_call_info_t *)OPERAND_AT(iobj, j);
rb_str_catf(str, "<callinfo:%s, %d>", ci->mid ? rb_id2name(ci->mid) : "", ci->orig_argc);
if (ci->orig_argc > 60) {
rb_bug("xyzzy");
}
break;
}
case TS_CDHASH: /* case/when condition cache */
rb_str_cat2(str, "<ch>");
break;
@ -5282,8 +5308,7 @@ dump_disasm_list(struct iseq_link_element *link)
{
iobj = (INSN *)link;
str = insn_data_to_s_detail(iobj);
printf("%04d %-65s(%4d)\n", pos, StringValueCStr(str),
insn_data_line_no(iobj));
printf("%04d %-65s(%4d)\n", pos, StringValueCStr(str), insn_data_line_no(iobj));
pos += insn_data_length(iobj);
break;
}
@ -5422,6 +5447,23 @@ insn_make_insn_table(void)
return table;
}
static VALUE
iseq_build_load_iseq(rb_iseq_t *iseq, VALUE op)
{
VALUE iseqval;
if (RB_TYPE_P(op, T_ARRAY)) {
iseqval = rb_iseq_load(op, iseq->self, Qnil);
}
else if (CLASS_OF(op) == rb_cISeq) {
iseqval = op;
}
else {
rb_raise(rb_eSyntaxError, "ISEQ is required");
}
iseq_add_mark_object(iseq, iseqval);
return iseqval;
}
static int
iseq_build_from_ary_body(rb_iseq_t *iseq, LINK_ANCHOR *anchor,
VALUE body, struct st_table *labels_table)
@ -5492,16 +5534,7 @@ iseq_build_from_ary_body(rb_iseq_t *iseq, LINK_ANCHOR *anchor,
case TS_ISEQ:
{
if (op != Qnil) {
if (RB_TYPE_P(op, T_ARRAY)) {
argv[j] = rb_iseq_load(op, iseq->self, Qnil);
}
else if (CLASS_OF(op) == rb_cISeq) {
argv[j] = op;
}
else {
rb_raise(rb_eSyntaxError, "ISEQ is required");
}
iseq_add_mark_object(iseq, argv[j]);
argv[j] = iseq_build_load_iseq(iseq, op);
}
else {
argv[j] = 0;
@ -5519,10 +5552,26 @@ iseq_build_from_ary_body(rb_iseq_t *iseq, LINK_ANCHOR *anchor,
}
break;
case TS_CALLINFO:
argv[j] = op;
if (NUM2INT(op) >= iseq->callinfo_size) {
iseq->callinfo_size = NUM2INT(op) + 1;
{
ID mid = 0;
int orig_argc = 0;
VALUE block = 0;
unsigned long flag = 0;
if (!NIL_P(op)) {
VALUE vmid = rb_hash_aref(op, ID2SYM(rb_intern("mid")));
VALUE vflag = rb_hash_aref(op, ID2SYM(rb_intern("flag")));
VALUE vorig_argc = rb_hash_aref(op, ID2SYM(rb_intern("orig_argc")));
VALUE vblock = rb_hash_aref(op, ID2SYM(rb_intern("block")));
if (!NIL_P(vmid)) mid = SYM2ID(vmid);
if (!NIL_P(vflag)) flag = NUM2ULONG(vflag);
if (!NIL_P(vorig_argc)) orig_argc = FIX2INT(vorig_argc);
if (!NIL_P(vblock)) block = iseq_build_load_iseq(iseq, vblock);
}
argv[j] = (VALUE)new_callinfo(iseq, mid, orig_argc, block, flag);
}
break;
case TS_ID:
argv[j] = rb_convert_type(op, T_SYMBOL,
"Symbol", "to_sym");

140
insns.def
View file

@ -952,100 +952,62 @@ defineclass
/**
@c method/iterator
@e obj.send(id, args..) # args.size => num
@j メソッド呼び出しを行う。
obj.send(id, args..) # args.size => num
flag & VM_CALL_ARGS_SPLAT_BIT != 0 -> splat last arg
flag & VM_CALL_ARGS_BLOCKARG_BIT != 0 -> Proc as Block
flag & VM_CALL_FCALL_BIT != 0 -> FCALL ( func() )
flag & VM_CALL_VCALL_BIT != 0 -> VCALL ( func )
...
@e invoke method.
@j メソッド呼び出しを行う。ci に必要な情報が格納されている。
*/
DEFINE_INSN
send
(ID op_id, rb_num_t op_argc, ISEQ blockiseq, rb_num_t op_flag, CALL_INFO ci)
(CALL_INFO ci)
(...)
(VALUE val) // inc += - (int)(op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));
(VALUE val) // inc += - (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));
{
const rb_method_entry_t *me;
VALUE recv, klass, defined_class;
rb_block_t *blockptr = 0;
VALUE flag = op_flag;
int num = caller_setup_args(th, GET_CFP(), flag, (int)op_argc,
(rb_iseq_t *)blockiseq, &blockptr);
ID id = op_id;
ci->argc = ci->orig_argc;
ci->blockptr = 0;
/* get receiver */
recv = TOPN(num);
klass = CLASS_OF(recv);
me = vm_method_search(id, klass, ci, &defined_class);
CALL_METHOD(num, blockptr, flag, id, me, recv, defined_class);
if (!LIKELY(ci->flag & VM_CALL_ARGS_SKIP_SETUP)) {
vm_caller_setup_args(th, reg_cfp, ci);
}
vm_search_method(ci, ci->recv = TOPN(ci->argc));
CALL_METHOD(ci);
}
/**
@c method/iterator
@e super(args) # args.size => num
@j super を実行する。
super(args) # args.size => num
flag 等オペランドの意味は send と同じ。
@j super を実行する。ci に必要な情報が格納されている。
*/
DEFINE_INSN
invokesuper
(rb_num_t op_argc, ISEQ blockiseq, rb_num_t op_flag)
(CALL_INFO ci)
(...)
(VALUE val) // inc += - (int)(op_argc + ((op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));
(VALUE val) // inc += - (int)(ci->orig_argc + ((ci->flag & VM_CALL_ARGS_BLOCKARG_BIT) ? 1 : 0));
{
rb_block_t *blockptr = !(op_flag & VM_CALL_ARGS_BLOCKARG_BIT) ? GET_BLOCK_PTR() : 0;
VALUE flag = op_flag;
int num = caller_setup_args(th, GET_CFP(), flag,
(int)op_argc, blockiseq, &blockptr);
VALUE recv, klass;
ID id;
const rb_method_entry_t *me;
rb_iseq_t *ip;
ci->argc = ci->orig_argc;
ci->blockptr = !(ci->flag & VM_CALL_ARGS_BLOCKARG_BIT) ? GET_BLOCK_PTR() : 0;
flag = VM_CALL_SUPER_BIT | VM_CALL_FCALL_BIT;
klass = GET_CFP()->klass;
if (NIL_P(klass)) {
vm_super_outside();
if (!LIKELY(ci->flag & VM_CALL_ARGS_SKIP_SETUP)) {
vm_caller_setup_args(th, reg_cfp, ci);
}
if (!NIL_P(RCLASS_REFINED_CLASS(klass))) {
klass = RCLASS_REFINED_CLASS(klass);
}
recv = GET_SELF();
if (!rb_obj_is_kind_of(recv, klass)) {
rb_raise(rb_eNotImpError, "super from singleton method that is defined to multiple classes is not supported; this will be fixed in 2.0.0 or later");
}
vm_search_superclass(GET_CFP(), GET_ISEQ(), TOPN(num), &id, &klass);
ip = GET_ISEQ();
while (ip && !ip->klass) {
ip = ip->parent_iseq;
}
me = rb_method_entry(klass, id, &klass);
if (me && me->def->type == VM_METHOD_TYPE_ISEQ &&
me->def->body.iseq == ip) {
klass = RCLASS_SUPER(klass);
me = rb_method_entry_get_with_refinements(Qnil, klass, id, &klass);
}
CALL_METHOD(num, blockptr, flag, id, me, recv, klass);
ci->recv = GET_SELF();
vm_search_super_method(th, GET_CFP(), ci);
CALL_METHOD(ci);
}
/**
@c method/iterator
@e yield(args) # args.size => num, flag shows expand argument or not
@e yield(args)
@j yield を実行する。
yield(args) # args.size => num
*/
DEFINE_INSN
invokeblock
(rb_num_t num, rb_num_t flag)
(CALL_INFO ci)
(...)
(VALUE val) // inc += 1 - num;
(VALUE val) // inc += 1 - ci->orig_argc;
{
val = vm_invoke_block(th, GET_CFP(), num, flag);
ci->argc = ci->orig_argc;
ci->blockptr = 0;
ci->recv = GET_SELF();
val = vm_invoke_block(th, GET_CFP(), ci);
if (val == Qundef) {
RESTORE_REGS();
NEXT_INSN();
@ -1338,7 +1300,7 @@ opt_plus
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idPLUS, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1386,7 +1348,7 @@ opt_minus
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idMINUS, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1439,7 +1401,7 @@ opt_mult
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idMULT, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1502,7 +1464,7 @@ opt_div
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idDIV, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1566,7 +1528,7 @@ opt_mod
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idMOD, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1587,7 +1549,7 @@ opt_eq
/* other */
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idEq, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1603,10 +1565,10 @@ opt_neq
(VALUE val)
{
extern VALUE rb_obj_not_equal(VALUE obj1, VALUE obj2);
const rb_method_entry_t *me = vm_method_search(idNeq, CLASS_OF(recv), ci, 0);
vm_search_method(ci, recv);
val = Qundef;
if (check_cfunc(me, rb_obj_not_equal)) {
if (check_cfunc(ci->me, rb_obj_not_equal)) {
val = opt_eq_func(recv, obj, ci_eq);
if (val != Qundef) {
@ -1618,7 +1580,7 @@ opt_neq
/* other */
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idNeq, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1662,7 +1624,7 @@ opt_lt
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idLT, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1697,7 +1659,7 @@ opt_le
/* other */
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idLE, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1741,7 +1703,7 @@ opt_gt
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idGT, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1775,7 +1737,7 @@ opt_ge
else {
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idGE, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1807,7 +1769,7 @@ opt_ltlt
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idLTLT, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1837,7 +1799,7 @@ opt_aref
INSN_LABEL(normal_dispatch):
PUSH(recv);
PUSH(obj);
CALL_SIMPLE_METHOD(1, idAREF, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1870,7 +1832,7 @@ opt_aset
PUSH(recv);
PUSH(obj);
PUSH(set);
CALL_SIMPLE_METHOD(2, idASET, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1905,7 +1867,7 @@ opt_length
else {
INSN_LABEL(normal_dispatch):
PUSH(recv);
CALL_SIMPLE_METHOD(0, idLength, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1940,7 +1902,7 @@ opt_size
else {
INSN_LABEL(normal_dispatch):
PUSH(recv);
CALL_SIMPLE_METHOD(0, idSize, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -1978,7 +1940,7 @@ opt_empty_p
else {
INSN_LABEL(normal_dispatch):
PUSH(recv);
CALL_SIMPLE_METHOD(0, idEmptyP, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -2025,7 +1987,7 @@ opt_succ
if (0) {
INSN_LABEL(normal_dispatch):
PUSH(recv);
CALL_SIMPLE_METHOD(0, idSucc, recv);
CALL_SIMPLE_METHOD(recv);
}
}
@ -2041,14 +2003,14 @@ opt_not
(VALUE val)
{
extern VALUE rb_obj_not(VALUE obj);
const rb_method_entry_t *me = vm_method_search(idNot, CLASS_OF(recv), ci, 0);
vm_search_method(ci, recv);
if (check_cfunc(me, rb_obj_not)) {
if (check_cfunc(ci->me, rb_obj_not)) {
val = RTEST(recv) ? Qfalse : Qtrue;
}
else {
PUSH(recv);
CALL_SIMPLE_METHOD(0, idNot, recv);
CALL_SIMPLE_METHOD(recv);
}
}

44
iseq.c
View file

@ -149,6 +149,7 @@ iseq_memsize(const void *ptr)
size += iseq->catch_table_size * sizeof(struct iseq_catch_table_entry);
size += iseq->arg_opts * sizeof(VALUE);
size += iseq->ic_size * sizeof(struct iseq_inline_cache_entry);
size += iseq->callinfo_size * sizeof(rb_call_info_t);
if (iseq->compile_data) {
struct iseq_compile_data_storage *cur;
@ -1041,7 +1042,37 @@ insn_operand_intern(rb_iseq_t *iseq,
break;
case TS_CALLINFO:
ret = rb_sprintf("<ci:%"PRIdPTRDIFF">", (rb_call_info_t *)op - iseq->callinfo_entries);
{
rb_call_info_t *ci = (rb_call_info_t *)op;
VALUE ary = rb_ary_new();
if (ci->mid) {
rb_ary_push(ary, rb_sprintf("mid:%s", rb_id2name(ci->mid)));
}
rb_ary_push(ary, rb_sprintf("argc:%d", ci->orig_argc));
if (ci->blockiseq) {
if (child) {
rb_ary_push(child, ci->blockiseq->self);
}
rb_ary_push(ary, rb_sprintf("block:%"PRIsVALUE, ci->blockiseq->location.label));
}
if (ci->flag) {
VALUE flags = rb_ary_new();
if (ci->flag & VM_CALL_ARGS_SPLAT_BIT) rb_ary_push(flags, rb_str_new2("ARGS_SPLAT"));
if (ci->flag & VM_CALL_ARGS_BLOCKARG_BIT) rb_ary_push(flags, rb_str_new2("ARGS_BLOCKARG"));
if (ci->flag & VM_CALL_FCALL_BIT) rb_ary_push(flags, rb_str_new2("FCALL"));
if (ci->flag & VM_CALL_VCALL_BIT) rb_ary_push(flags, rb_str_new2("VCALL"));
if (ci->flag & VM_CALL_TAILCALL_BIT) rb_ary_push(flags, rb_str_new2("TAILCALL"));
if (ci->flag & VM_CALL_SUPER_BIT) rb_ary_push(flags, rb_str_new2("SUPER"));
if (ci->flag & VM_CALL_OPT_SEND_BIT) rb_ary_push(flags, rb_str_new2("SNED")); /* maybe not reachable */
if (ci->flag & VM_CALL_ARGS_SKIP_SETUP) rb_ary_push(flags, rb_str_new2("ARGS_SKIP"));
rb_ary_push(ary, rb_ary_join(flags, rb_str_new2("|")));
}
ret = rb_sprintf("<callinfo!%"PRIsVALUE">", rb_ary_join(ary, rb_str_new2(", ")));
}
break;
case TS_CDHASH:
@ -1542,6 +1573,17 @@ iseq_data_to_ary(rb_iseq_t *iseq)
rb_ary_push(ary, INT2FIX(ic - iseq->ic_entries));
}
break;
case TS_CALLINFO:
{
rb_call_info_t *ci = (rb_call_info_t *)*seq;
VALUE e = rb_hash_new();
rb_hash_aset(e, ID2SYM(rb_intern("mid")), ci->mid ? ID2SYM(ci->mid) : Qnil);
rb_hash_aset(e, ID2SYM(rb_intern("flag")), ULONG2NUM(ci->flag));
rb_hash_aset(e, ID2SYM(rb_intern("orig_argc")), INT2FIX(ci->orig_argc));
rb_hash_aset(e, ID2SYM(rb_intern("blockptr")), ci->blockiseq ? iseq_data_to_ary(ci->blockiseq) : Qnil);
rb_ary_push(ary, e);
}
break;
case TS_ID:
rb_ary_push(ary, ID2SYM(*seq));
break;

8
tool/instruction.rb
View file

@ -66,11 +66,15 @@ class RubyVM
ret = "int inc = 0;\n"
@opes.each_with_index{|(t, v), i|
if t == 'rb_num_t' && ((re = /\b#{v}\b/n) =~ @sp_inc ||
@defopes.any?{|t, val| re =~ val})
if (t == 'rb_num_t' && ((re = /\b#{v}\b/n) =~ @sp_inc)) ||
(@defopes.any?{|t, val| re =~ val})
ret << " int #{v} = FIX2INT(opes[#{i}]);\n"
elsif (t == 'CALL_INFO' && ((re = /\b#{v}\b/n) =~ @sp_inc))
ret << " CALL_INFO #{v} = (CALL_INFO)(opes[#{i}]);\n"
end
}
@defopes.each_with_index{|((t, var), val), i|
if t == 'rb_num_t' && val != '*' && /\b#{var}\b/ =~ @sp_inc
ret << " #{t} #{var} = #{val};\n"

25
vm_core.h
View file

@ -138,15 +138,31 @@ struct iseq_inline_cache_entry {
} ic_value;
};
/* to avoid warning */
struct rb_thread_struct;
struct rb_control_frame_struct;
/* rb_call_info_t contains calling information including inline cache */
typedef struct rb_call_info_struct {
/* fixed at compile time */
ID mid;
VALUE flag;
int orig_argc;
rb_iseq_t *blockiseq;
/* inline cache: keys */
VALUE ic_vmstat;
VALUE ic_class;
VALUE vmstat;
VALUE klass;
/* inline cache: values */
rb_method_entry_t *method;
const rb_method_entry_t *me;
VALUE defined_class;
/* temporary values for method calling */
int argc;
struct rb_block_struct *blockptr;
VALUE recv;
VALUE (*call)(struct rb_thread_struct *th, struct rb_control_frame_struct *cfp, struct rb_call_info_struct *ci);
} rb_call_info_t;
#if 1
@ -367,7 +383,7 @@ typedef struct rb_vm_struct {
#define VM_DEBUG_BP_CHECK 1
#endif
typedef struct {
typedef struct rb_control_frame_struct {
VALUE *pc; /* cfp[0] */
VALUE *sp; /* cfp[1] */
rb_iseq_t *iseq; /* cfp[2] */
@ -640,6 +656,7 @@ enum vm_check_match_type {
#define VM_CALL_TAILRECURSION_BIT (0x01 << 6)
#define VM_CALL_SUPER_BIT (0x01 << 7)
#define VM_CALL_OPT_SEND_BIT (0x01 << 8)
#define VM_CALL_ARGS_SKIP_SETUP (0x01 << 9)
enum vm_special_object_type {
VM_SPECIAL_OBJECT_VMCORE = 1,

41
vm_eval.c
View file

@ -37,14 +37,23 @@ vm_call0(rb_thread_t* th, VALUE recv, VALUE id, int argc, const VALUE *argv,
{
const rb_method_definition_t *def = me->def;
VALUE val;
VALUE klass = defined_class;
const rb_block_t *blockptr = 0;
rb_call_info_t ci_entry, *ci = &ci_entry;
ci->flag = 0;
ci->mid = id;
ci->recv = recv;
ci->defined_class = defined_class;
ci->argc = argc;
ci->me = me;
if (!def) return Qnil;
if (th->passed_block) {
blockptr = th->passed_block;
ci->blockptr = (rb_block_t *)th->passed_block;
th->passed_block = 0;
}
else {
ci->blockptr = 0;
}
again:
switch (def->type) {
@ -59,20 +68,19 @@ vm_call0(rb_thread_t* th, VALUE recv, VALUE id, int argc, const VALUE *argv,
*reg_cfp->sp++ = argv[i];
}
vm_setup_method(th, reg_cfp, recv, argc, blockptr, 0 /* flag */,
me, klass);
vm_setup_method(th, reg_cfp, ci);
th->cfp->flag |= VM_FRAME_FLAG_FINISH;
val = vm_exec(th);
break;
}
case VM_METHOD_TYPE_NOTIMPLEMENTED:
case VM_METHOD_TYPE_CFUNC: {
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, id, klass);
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, ci->recv, ci->mid, ci->defined_class);
{
rb_control_frame_t *reg_cfp = th->cfp;
rb_control_frame_t *cfp =
vm_push_frame(th, 0, VM_FRAME_MAGIC_CFUNC,
recv, klass, VM_ENVVAL_BLOCK_PTR(blockptr),
ci->recv, ci->defined_class, VM_ENVVAL_BLOCK_PTR(ci->blockptr),
0, reg_cfp->sp, 1, me);
cfp->me = me;
@ -83,7 +91,7 @@ vm_call0(rb_thread_t* th, VALUE recv, VALUE id, int argc, const VALUE *argv,
}
vm_pop_frame(th);
}
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, id, klass);
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, ci->recv, ci->mid, ci->defined_class);
break;
}
case VM_METHOD_TYPE_ATTRSET: {
@ -97,13 +105,13 @@ vm_call0(rb_thread_t* th, VALUE recv, VALUE id, int argc, const VALUE *argv,
break;
}
case VM_METHOD_TYPE_BMETHOD: {
val = vm_call_bmethod(th, recv, argc, argv, blockptr, me, klass);
val = vm_call_bmethod(th, recv, argc, argv, ci->blockptr, me, ci->defined_class);
break;
}
case VM_METHOD_TYPE_ZSUPER: {
klass = RCLASS_SUPER(klass);
if (!klass || !(me = rb_method_entry(klass, id, &klass))) {
return method_missing(recv, id, argc, argv, NOEX_SUPER);
ci->defined_class = RCLASS_SUPER(ci->defined_class);
if (!ci->defined_class || !(ci->me = rb_method_entry(ci->defined_class, id, &ci->defined_class))) {
return method_missing(recv, ci->mid, ci->argc, argv, NOEX_SUPER);
}
RUBY_VM_CHECK_INTS(th);
if (!(def = me->def)) return Qnil;
@ -113,10 +121,9 @@ vm_call0(rb_thread_t* th, VALUE recv, VALUE id, int argc, const VALUE *argv,
VALUE new_args = rb_ary_new4(argc, argv);
RB_GC_GUARD(new_args);
rb_ary_unshift(new_args, ID2SYM(id));
th->passed_block = blockptr;
return rb_funcall2(recv, idMethodMissing,
argc+1, RARRAY_PTR(new_args));
rb_ary_unshift(new_args, ID2SYM(ci->mid));
th->passed_block = ci->blockptr;
return rb_funcall2(ci->recv, idMethodMissing, argc+1, RARRAY_PTR(new_args));
}
case VM_METHOD_TYPE_OPTIMIZED: {
switch (def->body.optimize_type) {
@ -126,7 +133,7 @@ vm_call0(rb_thread_t* th, VALUE recv, VALUE id, int argc, const VALUE *argv,
case OPTIMIZED_METHOD_TYPE_CALL: {
rb_proc_t *proc;
GetProcPtr(recv, proc);
val = rb_vm_invoke_proc(th, proc, argc, argv, blockptr);
val = rb_vm_invoke_proc(th, proc, argc, argv, ci->blockptr);
break;
}
default:

693
vm_insnhelper.c
View file

@ -158,27 +158,26 @@ rb_error_arity(int argc, int min, int max)
rb_exc_raise(rb_arg_error_new(argc, min, max));
}
#define VM_CALLEE_SETUP_ARG(ret, th, iseq, orig_argc, orig_argv, block) \
#define VM_CALLEE_SETUP_ARG(ret, th, ci, iseq, argv) \
if (LIKELY((iseq)->arg_simple & 0x01)) { \
/* simple check */ \
if ((orig_argc) != (iseq)->argc) { \
argument_error((iseq), (orig_argc), (iseq)->argc, (iseq)->argc); \
if ((ci)->argc != (iseq)->argc) { \
argument_error((iseq), ((ci)->argc), (iseq)->argc, (iseq)->argc); \
} \
(ret) = 0; \
} \
else { \
(ret) = vm_callee_setup_arg_complex((th), (iseq), (orig_argc), (orig_argv), (block)); \
(ret) = vm_callee_setup_arg_complex((th), (ci), (iseq), (argv)); \
}
static inline int
vm_callee_setup_arg_complex(rb_thread_t *th, const rb_iseq_t * iseq,
int orig_argc, VALUE * orig_argv,
const rb_block_t **block)
vm_callee_setup_arg_complex(rb_thread_t *th, rb_call_info_t *ci, const rb_iseq_t * iseq, VALUE *orig_argv)
{
const int m = iseq->argc;
const int opts = iseq->arg_opts - (iseq->arg_opts > 0);
const int min = m + iseq->arg_post_len;
const int max = (iseq->arg_rest == -1) ? m + opts + iseq->arg_post_len : UNLIMITED_ARGUMENTS;
const int orig_argc = ci->argc;
int argc = orig_argc;
VALUE *argv = orig_argv;
rb_num_t opt_pc = 0;
@ -255,9 +254,9 @@ vm_callee_setup_arg_complex(rb_thread_t *th, const rb_iseq_t * iseq,
}
/* block arguments */
if (block && iseq->arg_block != -1) {
if (iseq->arg_block != -1) {
VALUE blockval = Qnil;
const rb_block_t *blockptr = *block;
const rb_block_t *blockptr = ci->blockptr;
if (blockptr) {
/* make Proc object */
@ -265,7 +264,7 @@ vm_callee_setup_arg_complex(rb_thread_t *th, const rb_iseq_t * iseq,
rb_proc_t *proc;
blockval = rb_vm_make_proc(th, blockptr, rb_cProc);
GetProcPtr(blockval, proc);
*block = &proc->block;
ci->blockptr = &proc->block;
}
else {
blockval = blockptr->proc;
@ -279,14 +278,10 @@ vm_callee_setup_arg_complex(rb_thread_t *th, const rb_iseq_t * iseq,
return (int)opt_pc;
}
static inline int
caller_setup_args(const rb_thread_t *th, rb_control_frame_t *cfp, VALUE flag,
int argc, rb_iseq_t *blockiseq, rb_block_t **block)
static void
vm_caller_setup_args(const rb_thread_t *th, rb_control_frame_t *cfp, rb_call_info_t *ci)
{
rb_block_t *blockptr = 0;
if (block) {
if (flag & VM_CALL_ARGS_BLOCKARG_BIT) {
if (UNLIKELY(ci->flag & VM_CALL_ARGS_BLOCKARG_BIT)) {
rb_proc_t *po;
VALUE proc;
@ -303,21 +298,19 @@ caller_setup_args(const rb_thread_t *th, rb_control_frame_t *cfp, VALUE flag,
proc = b;
}
GetProcPtr(proc, po);
blockptr = &po->block;
ci->blockptr = &po->block;
RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp)->proc = proc;
*block = blockptr;
}
}
else if (blockiseq) {
blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
blockptr->iseq = blockiseq;
blockptr->proc = 0;
*block = blockptr;
}
else if (UNLIKELY(ci->blockiseq != 0)) {
ci->blockptr = RUBY_VM_GET_BLOCK_PTR_IN_CFP(cfp);
ci->blockptr->iseq = ci->blockiseq;
ci->blockptr->proc = 0;
}
/* expand top of stack? */
if (flag & VM_CALL_ARGS_SPLAT_BIT) {
if (UNLIKELY(ci->flag & VM_CALL_ARGS_SPLAT_BIT)) {
VALUE ary = *(cfp->sp - 1);
VALUE *ptr;
int i;
@ -336,11 +329,9 @@ caller_setup_args(const rb_thread_t *th, rb_control_frame_t *cfp, VALUE flag,
for (i = 0; i < len; i++) {
*cfp->sp++ = ptr[i];
}
argc += i-1;
ci->argc += i-1;
}
}
return argc;
}
static inline VALUE
@ -428,21 +419,20 @@ call_cfunc(VALUE (*func)(), VALUE recv,
}
static inline VALUE
vm_call_cfunc(rb_thread_t *th, rb_control_frame_t *reg_cfp,
int num, volatile VALUE recv, const rb_block_t *blockptr,
const rb_method_entry_t *me, VALUE defined_class)
vm_call_cfunc(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci)
{
volatile VALUE val = 0;
const rb_method_entry_t *me = ci->me;
const rb_method_definition_t *def = me->def;
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, recv, me->called_id, me->klass);
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_CALL, ci->recv, me->called_id, me->klass);
vm_push_frame(th, 0, VM_FRAME_MAGIC_CFUNC, recv, defined_class,
VM_ENVVAL_BLOCK_PTR(blockptr), 0, th->cfp->sp, 1, me);
vm_push_frame(th, 0, VM_FRAME_MAGIC_CFUNC, ci->recv, ci->defined_class,
VM_ENVVAL_BLOCK_PTR(ci->blockptr), 0, th->cfp->sp, 1, me);
reg_cfp->sp -= num + 1;
reg_cfp->sp -= ci->argc + 1;
val = call_cfunc(def->body.cfunc.func, recv, (int)def->body.cfunc.argc, num, reg_cfp->sp + 1);
val = call_cfunc(def->body.cfunc.func, ci->recv, (int)def->body.cfunc.argc, ci->argc, reg_cfp->sp + 1);
if (reg_cfp != th->cfp + 1) {
rb_bug("cfp consistency error - send");
@ -450,7 +440,7 @@ vm_call_cfunc(rb_thread_t *th, rb_control_frame_t *reg_cfp,
vm_pop_frame(th);
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, recv, me->called_id, me->klass);
EXEC_EVENT_HOOK(th, RUBY_EVENT_C_RETURN, ci->recv, me->called_id, me->klass);
return val;
}
@ -491,20 +481,18 @@ vm_method_missing(rb_thread_t *th, rb_control_frame_t *const reg_cfp,
}
static inline void
vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp,
VALUE recv, int argc, const rb_block_t *blockptr, VALUE flag,
const rb_method_entry_t *me, VALUE defined_class)
vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp, rb_call_info_t *ci)
{
int opt_pc, i;
VALUE *argv = cfp->sp - argc;
rb_iseq_t *iseq = me->def->body.iseq;
VALUE *argv = cfp->sp - ci->argc;
rb_iseq_t *iseq = ci->me->def->body.iseq;
VM_CALLEE_SETUP_ARG(opt_pc, th, iseq, argc, argv, &blockptr);
VM_CALLEE_SETUP_ARG(opt_pc, th, ci, iseq, argv);
/* stack overflow check */
CHECK_STACK_OVERFLOW(cfp, iseq->stack_max);
if (LIKELY(!(flag & VM_CALL_TAILCALL_BIT))) {
if (LIKELY(!(ci->flag & VM_CALL_TAILCALL_BIT))) {
VALUE *sp = argv + iseq->arg_size;
/* clear local variables */
@ -512,9 +500,9 @@ vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp,
*sp++ = Qnil;
}
vm_push_frame(th, iseq, VM_FRAME_MAGIC_METHOD, recv, defined_class,
VM_ENVVAL_BLOCK_PTR(blockptr),
iseq->iseq_encoded + opt_pc, sp, 0, me);
vm_push_frame(th, iseq, VM_FRAME_MAGIC_METHOD, ci->recv, ci->defined_class,
VM_ENVVAL_BLOCK_PTR(ci->blockptr),
iseq->iseq_encoded + opt_pc, sp, 0, ci->me);
cfp->sp = argv - 1 /* recv */;
}
@ -527,7 +515,7 @@ vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp,
sp_orig = sp = cfp->sp;
/* push self */
sp[0] = recv;
sp[0] = ci->recv;
sp++;
/* copy arguments */
@ -541,187 +529,13 @@ vm_setup_method(rb_thread_t *th, rb_control_frame_t *cfp,
}
vm_push_frame(th, iseq, VM_FRAME_MAGIC_METHOD | finish_flag,
recv, defined_class, VM_ENVVAL_BLOCK_PTR(blockptr),
iseq->iseq_encoded + opt_pc, sp, 0, me);
ci->recv, ci->defined_class, VM_ENVVAL_BLOCK_PTR(ci->blockptr),
iseq->iseq_encoded + opt_pc, sp, 0, ci->me);
cfp->sp = sp_orig;
}
}
static inline VALUE
vm_call_method(rb_thread_t *th, rb_control_frame_t *cfp,
int num, const rb_block_t *blockptr, VALUE flag,
ID id, const rb_method_entry_t *me,
VALUE recv, VALUE defined_class)
{
VALUE val;
start_method_dispatch:
if (me != 0) {
if ((me->flag == 0)) {
normal_method_dispatch:
switch (me->def->type) {
case VM_METHOD_TYPE_ISEQ:{
vm_setup_method(th, cfp, recv, num, blockptr, flag, me,
defined_class);
return Qundef;
}
case VM_METHOD_TYPE_NOTIMPLEMENTED:
case VM_METHOD_TYPE_CFUNC:{
val = vm_call_cfunc(th, cfp, num, recv, blockptr, me,
defined_class);
break;
}
case VM_METHOD_TYPE_ATTRSET:{
rb_check_arity(num, 1, 1);
val = rb_ivar_set(recv, me->def->body.attr.id, *(cfp->sp - 1));
cfp->sp -= 2;
break;
}
case VM_METHOD_TYPE_IVAR:{
rb_check_arity(num, 0, 0);
val = rb_attr_get(recv, me->def->body.attr.id);
cfp->sp -= 1;
break;
}
case VM_METHOD_TYPE_MISSING:{
VALUE *argv = ALLOCA_N(VALUE, num+1);
argv[0] = ID2SYM(me->def->original_id);
MEMCPY(argv+1, cfp->sp - num, VALUE, num);
cfp->sp += - num - 1;
th->passed_block = blockptr;
val = rb_funcall2(recv, rb_intern("method_missing"), num+1, argv);
break;
}
case VM_METHOD_TYPE_BMETHOD:{
VALUE *argv = ALLOCA_N(VALUE, num);
MEMCPY(argv, cfp->sp - num, VALUE, num);
cfp->sp += - num - 1;
val = vm_call_bmethod(th, recv, num, argv, blockptr, me,
defined_class);
break;
}
case VM_METHOD_TYPE_ZSUPER:{
VALUE klass = RCLASS_SUPER(me->klass);
me = rb_method_entry(klass, id, &defined_class);
if (me != 0) {
goto normal_method_dispatch;
}
else {
goto start_method_dispatch;
}
}
case VM_METHOD_TYPE_OPTIMIZED:{
switch (me->def->body.optimize_type) {
case OPTIMIZED_METHOD_TYPE_SEND: {
rb_control_frame_t *reg_cfp = cfp;
rb_num_t i = num - 1;
VALUE sym;
if (num == 0) {
rb_raise(rb_eArgError, "no method name given");
}
sym = TOPN(i);
if (SYMBOL_P(sym)) {
id = SYM2ID(sym);
}
else if (!(id = rb_check_id(&sym))) {
if (rb_method_basic_definition_p(CLASS_OF(recv), idMethodMissing)) {
VALUE exc = make_no_method_exception(rb_eNoMethodError, NULL, recv,
rb_long2int(num), &TOPN(i));
rb_exc_raise(exc);
}
id = rb_to_id(sym);
}
/* shift arguments */
if (i > 0) {
MEMMOVE(&TOPN(i), &TOPN(i-1), VALUE, i);
}
me = rb_method_entry(CLASS_OF(recv), id, &defined_class);
num -= 1;
DEC_SP(1);
flag |= VM_CALL_FCALL_BIT | VM_CALL_OPT_SEND_BIT;
goto start_method_dispatch;
}
case OPTIMIZED_METHOD_TYPE_CALL: {
rb_proc_t *proc;
int argc = num;
VALUE *argv = ALLOCA_N(VALUE, num);
GetProcPtr(recv, proc);
MEMCPY(argv, cfp->sp - num, VALUE, num);
cfp->sp -= num + 1;
val = rb_vm_invoke_proc(th, proc, argc, argv, blockptr);
break;
}
default:
rb_bug("eval_invoke_method: unsupported optimized method type (%d)",
me->def->body.optimize_type);
}
break;
}
default:{
rb_bug("eval_invoke_method: unsupported method type (%d)", me->def->type);
break;
}
}
}
else {
int noex_safe;
if (!(flag & VM_CALL_FCALL_BIT) &&
(me->flag & NOEX_MASK) & NOEX_PRIVATE) {
int stat = NOEX_PRIVATE;
if (flag & VM_CALL_VCALL_BIT) {
stat |= NOEX_VCALL;
}
val = vm_method_missing(th, cfp, id, recv, num, blockptr, stat);
}
else if (!(flag & VM_CALL_OPT_SEND_BIT) && (me->flag & NOEX_MASK) & NOEX_PROTECTED) {
if (!rb_obj_is_kind_of(cfp->self, defined_class)) {
val = vm_method_missing(th, cfp, id, recv, num, blockptr, NOEX_PROTECTED);
}
else {
goto normal_method_dispatch;
}
}
else if ((noex_safe = NOEX_SAFE(me->flag)) > th->safe_level &&
(noex_safe > 2)) {
rb_raise(rb_eSecurityError, "calling insecure method: %s", rb_id2name(id));
}
else {
goto normal_method_dispatch;
}
}
}
else {
/* method missing */
int stat = 0;
if (flag & VM_CALL_VCALL_BIT) {
stat |= NOEX_VCALL;
}
if (flag & VM_CALL_SUPER_BIT) {
stat |= NOEX_SUPER;
}
if (id == idMethodMissing) {
rb_control_frame_t *reg_cfp = cfp;
VALUE *argv = STACK_ADDR_FROM_TOP(num);
rb_raise_method_missing(th, num, argv, recv, stat);
}
else {
val = vm_method_missing(th, cfp, id, recv, num, blockptr, stat);
}
}
RUBY_VM_CHECK_INTS(th);
return val;
}
/* yield */
static inline int
@ -938,8 +752,7 @@ vm_yield_setup_block_args(rb_thread_t *th, const rb_iseq_t * iseq,
static inline int
vm_yield_setup_args(rb_thread_t * const th, const rb_iseq_t *iseq,
int argc, VALUE *argv,
const rb_block_t *blockptr, int lambda)
int argc, VALUE *argv, const rb_block_t *blockptr, int lambda)
{
if (0) { /* for debug */
printf(" argc: %d\n", argc);
@ -955,7 +768,11 @@ vm_yield_setup_args(rb_thread_t * const th, const rb_iseq_t *iseq,
if (lambda) {
/* call as method */
int opt_pc;
VM_CALLEE_SETUP_ARG(opt_pc, th, iseq, argc, argv, &blockptr);
rb_call_info_t ci_entry;
ci_entry.flag = 0;
ci_entry.argc = argc;
ci_entry.blockptr = (rb_block_t *)blockptr;
VM_CALLEE_SETUP_ARG(opt_pc, th, &ci_entry, iseq, argv);
return opt_pc;
}
else {
@ -964,11 +781,10 @@ vm_yield_setup_args(rb_thread_t * const th, const rb_iseq_t *iseq,
}
static VALUE
vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_num_t num, rb_num_t flag)
vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci)
{
const rb_block_t *block = VM_CF_BLOCK_PTR(reg_cfp);
rb_iseq_t *iseq;
int argc = (int)num;
VALUE type = GET_ISEQ()->local_iseq->type;
if ((type != ISEQ_TYPE_METHOD && type != ISEQ_TYPE_CLASS) || block == 0) {
@ -976,17 +792,16 @@ vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_num_t num, rb_n
}
iseq = block->iseq;
argc = caller_setup_args(th, GET_CFP(), flag, argc, 0, 0);
vm_caller_setup_args(th, GET_CFP(), ci);
if (BUILTIN_TYPE(iseq) != T_NODE) {
int opt_pc;
const int arg_size = iseq->arg_size;
VALUE * const rsp = GET_SP() - argc;
VALUE * const rsp = GET_SP() - ci->argc;
SET_SP(rsp);
CHECK_STACK_OVERFLOW(GET_CFP(), iseq->stack_max);
opt_pc = vm_yield_setup_args(th, iseq, argc, rsp, 0,
block_proc_is_lambda(block->proc));
opt_pc = vm_yield_setup_args(th, iseq, ci->argc, rsp, 0, block_proc_is_lambda(block->proc));
vm_push_frame(th, iseq, VM_FRAME_MAGIC_BLOCK, block->self,
block->klass,
@ -998,8 +813,8 @@ vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_num_t num, rb_n
return Qundef;
}
else {
VALUE val = vm_yield_with_cfunc(th, block, block->self, argc, STACK_ADDR_FROM_TOP(argc), 0);
POPN(argc); /* TODO: should put before C/yield? */
VALUE val = vm_yield_with_cfunc(th, block, block->self, ci->argc, STACK_ADDR_FROM_TOP(ci->argc), 0);
POPN(ci->argc); /* TODO: should put before C/yield? */
return val;
}
}
@ -1429,105 +1244,6 @@ vm_setivar(VALUE obj, ID id, VALUE val, IC ic)
#endif
}
static inline const rb_method_entry_t *
vm_method_search(VALUE id, VALUE klass, CALL_INFO ci, VALUE *defined_class_ptr)
{
rb_method_entry_t *me;
#if OPT_INLINE_METHOD_CACHE
if (LIKELY(klass == ci->ic_class &&
GET_VM_STATE_VERSION() == ci->ic_vmstat)) {
me = ci->method;
if (defined_class_ptr) {
*defined_class_ptr = ci->defined_class;
}
}
else {
VALUE defined_class;
me = rb_method_entry(klass, id, &defined_class);
if (defined_class_ptr) {
*defined_class_ptr = defined_class;
}
ci->ic_class = klass;
ci->method = me;
ci->defined_class = defined_class;
ci->ic_vmstat = GET_VM_STATE_VERSION();
}
#else
me = rb_method_entry(klass, id, defined_class_ptr);
#endif
return me;
}
static inline VALUE
vm_search_normal_superclass(VALUE klass)
{
klass = RCLASS_ORIGIN(klass);
return RCLASS_SUPER(klass);
}
static void
vm_super_outside(void)
{
rb_raise(rb_eNoMethodError, "super called outside of method");
}
static void
vm_search_superclass(rb_control_frame_t *reg_cfp, rb_iseq_t *iseq,
VALUE sigval,
ID *idp, VALUE *klassp)
{
ID id;
VALUE klass;
while (iseq && !iseq->klass) {
iseq = iseq->parent_iseq;
}
if (iseq == 0) {
vm_super_outside();
}
id = iseq->defined_method_id;
if (iseq != iseq->local_iseq) {
/* defined by Module#define_method() */
rb_control_frame_t *lcfp = GET_CFP();
if (!sigval) {
/* zsuper */
rb_raise(rb_eRuntimeError, "implicit argument passing of super from method defined by define_method() is not supported. Specify all arguments explicitly.");
}
while (lcfp->iseq != iseq) {
rb_thread_t *th = GET_THREAD();
VALUE *tep = VM_EP_PREV_EP(lcfp->ep);
while (1) {
lcfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(lcfp);
if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, lcfp)) {
vm_super_outside();
}
if (lcfp->ep == tep) {
break;
}
}
}
/* temporary measure for [Bug #2420] [Bug #3136] */
if (!lcfp->me) {
vm_super_outside();
}
id = lcfp->me->def->original_id;
klass = vm_search_normal_superclass(lcfp->klass);
}
else {
klass = vm_search_normal_superclass(reg_cfp->klass);
}
*idp = id;
*klassp = klass;
}
static VALUE
vm_throw(rb_thread_t *th, rb_control_frame_t *reg_cfp,
rb_num_t throw_state, VALUE throwobj)
@ -1758,6 +1474,32 @@ vm_expandarray(rb_control_frame_t *cfp, VALUE ary, rb_num_t num, int flag)
RB_GC_GUARD(ary);
}
static VALUE vm_call_general(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci);
static void
vm_search_method(rb_call_info_t *ci, VALUE recv)
{
VALUE klass = CLASS_OF(recv);
rb_method_entry_t *me;
#if OPT_INLINE_METHOD_CACHE
if (LIKELY(GET_VM_STATE_VERSION() == ci->vmstat && klass == ci->klass)) {
/* cache hit! */
}
else {
me = rb_method_entry(klass, ci->mid, &ci->defined_class);
ci->me = me;
ci->klass = klass;
ci->vmstat = GET_VM_STATE_VERSION();
ci->call = vm_call_general;
}
#else
ci->method = rb_method_entry(klass, id, &ci->defined_class);
ci->call = vm_call_general;
ci->klass = klass;
#endif
}
static inline int
check_cfunc(const rb_method_entry_t *me, VALUE (*func)())
{
@ -1805,9 +1547,9 @@ opt_eq_func(VALUE recv, VALUE obj, CALL_INFO ci)
}
{
const rb_method_entry_t *me = vm_method_search(idEq, CLASS_OF(recv), ci, 0);
vm_search_method(ci, recv);
if (check_cfunc(me, rb_obj_equal)) {
if (check_cfunc(ci->me, rb_obj_equal)) {
return recv == obj ? Qtrue : Qfalse;
}
}
@ -1927,3 +1669,280 @@ vm_base_ptr(rb_control_frame_t *cfp)
return bp;
}
static inline VALUE
vm_call_method(rb_thread_t *th, rb_control_frame_t *cfp, rb_call_info_t *ci)
{
VALUE val;
start_method_dispatch:
if (ci->me != 0) {
if ((ci->me->flag == 0)) {
normal_method_dispatch:
switch (ci->me->def->type) {
case VM_METHOD_TYPE_ISEQ:{
vm_setup_method(th, cfp, ci);
return Qundef;
}
case VM_METHOD_TYPE_NOTIMPLEMENTED:
case VM_METHOD_TYPE_CFUNC:{
val = vm_call_cfunc(th, cfp, ci);
break;
}
case VM_METHOD_TYPE_ATTRSET:{
rb_check_arity(ci->argc, 1, 1);
val = rb_ivar_set(ci->recv, ci->me->def->body.attr.id, *(cfp->sp - 1));
cfp->sp -= 2;
break;
}
case VM_METHOD_TYPE_IVAR:{
rb_check_arity(ci->argc, 0, 0);
val = rb_attr_get(ci->recv, ci->me->def->body.attr.id);
cfp->sp -= 1;
break;
}
case VM_METHOD_TYPE_MISSING:{
VALUE *argv = ALLOCA_N(VALUE, ci->argc+1);
argv[0] = ID2SYM(ci->me->def->original_id);
MEMCPY(argv+1, cfp->sp - ci->argc, VALUE, ci->argc);
cfp->sp += - ci->argc - 1;
th->passed_block = ci->blockptr;
val = rb_funcall2(ci->recv, rb_intern("method_missing"), ci->argc+1, argv);
break;
}
case VM_METHOD_TYPE_BMETHOD:{
VALUE *argv = ALLOCA_N(VALUE, ci->argc);
MEMCPY(argv, cfp->sp - ci->argc, VALUE, ci->argc);
cfp->sp += - ci->argc - 1;
val = vm_call_bmethod(th, ci->recv, ci->argc, argv,
ci->blockptr, ci->me, ci->defined_class);
break;
}
case VM_METHOD_TYPE_ZSUPER:{
VALUE klass = RCLASS_SUPER(ci->me->klass);
rb_call_info_t cie = *ci;
ci = &cie;
ci->me = rb_method_entry(klass, ci->mid, &ci->defined_class);
if (ci->me != 0) {
goto normal_method_dispatch;
}
else {
goto start_method_dispatch;
}
}
case VM_METHOD_TYPE_OPTIMIZED:{
switch (ci->me->def->body.optimize_type) {
case OPTIMIZED_METHOD_TYPE_SEND: {
rb_control_frame_t *reg_cfp = cfp;
int i = ci->argc - 1;
VALUE sym;
rb_call_info_t ci_entry;
if (ci->argc == 0) {
rb_raise(rb_eArgError, "no method name given");
}
ci_entry = *ci; /* copy ci entry */
ci = &ci_entry;
sym = TOPN(i);
if (SYMBOL_P(sym)) {
ci->mid = SYM2ID(sym);
}
else if (!(ci->mid = rb_check_id(&sym))) {
if (rb_method_basic_definition_p(CLASS_OF(ci->recv), idMethodMissing)) {
VALUE exc = make_no_method_exception(rb_eNoMethodError, NULL, ci->recv, rb_long2int(ci->argc), &TOPN(i));
rb_exc_raise(exc);
}
ci->mid = rb_to_id(sym);
}
/* shift arguments */
if (i > 0) {
MEMMOVE(&TOPN(i), &TOPN(i-1), VALUE, i);
}
ci->me = rb_method_entry(CLASS_OF(ci->recv), ci->mid, &ci->defined_class);
ci->argc -= 1;
DEC_SP(1);
/* TODO: fixme */
ci->flag |= VM_CALL_FCALL_BIT | VM_CALL_OPT_SEND_BIT;
goto start_method_dispatch;
}
case OPTIMIZED_METHOD_TYPE_CALL: {
rb_proc_t *proc;
int argc = ci->argc;
VALUE *argv = ALLOCA_N(VALUE, argc);
GetProcPtr(ci->recv, proc);
MEMCPY(argv, cfp->sp - argc, VALUE, argc);
cfp->sp -= argc + 1;
val = rb_vm_invoke_proc(th, proc, argc, argv, ci->blockptr);
break;
}
default:
rb_bug("eval_invoke_method: unsupported optimized method type (%d)",
ci->me->def->body.optimize_type);
}
break;
}
default:{
rb_bug("eval_invoke_method: unsupported method type (%d)", ci->me->def->type);
break;
}
}
}
else {
int noex_safe;
if (!(ci->flag & VM_CALL_FCALL_BIT) && (ci->me->flag & NOEX_MASK) & NOEX_PRIVATE) {
int stat = NOEX_PRIVATE;
if (ci->flag & VM_CALL_VCALL_BIT) {
stat |= NOEX_VCALL;
}
val = vm_method_missing(th, cfp, ci->mid, ci->recv, ci->argc, ci->blockptr, stat);
}
else if (!(ci->flag & VM_CALL_OPT_SEND_BIT) && (ci->me->flag & NOEX_MASK) & NOEX_PROTECTED) {
if (!rb_obj_is_kind_of(cfp->self, ci->defined_class)) {
val = vm_method_missing(th, cfp, ci->mid, ci->recv, ci->argc, ci->blockptr, NOEX_PROTECTED);
}
else {
goto normal_method_dispatch;
}
}
else if ((noex_safe = NOEX_SAFE(ci->me->flag)) > th->safe_level && (noex_safe > 2)) {
rb_raise(rb_eSecurityError, "calling insecure method: %s", rb_id2name(ci->mid));
}
else {
goto normal_method_dispatch;
}
}
}
else {
/* method missing */
int stat = 0;
if (ci->flag & VM_CALL_VCALL_BIT) {
stat |= NOEX_VCALL;
}
if (ci->flag & VM_CALL_SUPER_BIT) {
stat |= NOEX_SUPER;
}
if (ci->mid == idMethodMissing) {
rb_control_frame_t *reg_cfp = cfp;
VALUE *argv = STACK_ADDR_FROM_TOP(ci->argc);
rb_raise_method_missing(th, ci->argc, argv, ci->recv, stat);
}
else {
val = vm_method_missing(th, cfp, ci->mid, ci->recv, ci->argc, ci->blockptr, stat);
}
}
RUBY_VM_CHECK_INTS(th);
return val;
}
static inline VALUE
vm_search_normal_superclass(VALUE klass)
{
klass = RCLASS_ORIGIN(klass);
return RCLASS_SUPER(klass);
}
static void
vm_super_outside(void)
{
rb_raise(rb_eNoMethodError, "super called outside of method");
}
static void
vm_search_superclass(rb_control_frame_t *reg_cfp, rb_iseq_t *iseq, VALUE sigval, rb_call_info_t *ci)
{
while (iseq && !iseq->klass) {
iseq = iseq->parent_iseq;
}
if (iseq == 0) {
vm_super_outside();
}
ci->mid = iseq->defined_method_id;
if (iseq != iseq->local_iseq) {
/* defined by Module#define_method() */
rb_control_frame_t *lcfp = GET_CFP();
if (!sigval) {
/* zsuper */
rb_raise(rb_eRuntimeError, "implicit argument passing of super from method defined by define_method() is not supported. Specify all arguments explicitly.");
}
while (lcfp->iseq != iseq) {
rb_thread_t *th = GET_THREAD();
VALUE *tep = VM_EP_PREV_EP(lcfp->ep);
while (1) {
lcfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(lcfp);
if (RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, lcfp)) {
vm_super_outside();
}
if (lcfp->ep == tep) {
break;
}
}
}
/* temporary measure for [Bug #2420] [Bug #3136] */
if (!lcfp->me) {
vm_super_outside();
}
ci->mid = lcfp->me->def->original_id;
ci->klass = vm_search_normal_superclass(lcfp->klass);
}
else {
ci->klass = vm_search_normal_superclass(reg_cfp->klass);
}
}
static void
vm_search_super_method(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci)
{
VALUE current_defind_class;
rb_iseq_t *iseq = GET_ISEQ();
VALUE sigval = TOPN(ci->orig_argc);
current_defind_class = GET_CFP()->klass;
if (NIL_P(current_defind_class)) {
vm_super_outside();
}
if (!NIL_P(RCLASS_REFINED_CLASS(current_defind_class))) {
current_defind_class = RCLASS_REFINED_CLASS(current_defind_class);
}
if (!rb_obj_is_kind_of(ci->recv, current_defind_class)) {
rb_raise(rb_eNotImpError, "super from singleton method that is defined to multiple classes is not supported; this will be fixed in 2.0.0 or later");
}
vm_search_superclass(GET_CFP(), iseq, sigval, ci);
/* TODO: use inline cache */
ci->me = rb_method_entry(ci->klass, ci->mid, &ci->defined_class);
ci->call = vm_call_general;
while (iseq && !iseq->klass) {
iseq = iseq->parent_iseq;
}
if (ci->me && ci->me->def->type == VM_METHOD_TYPE_ISEQ && ci->me->def->body.iseq == iseq) {
ci->klass = RCLASS_SUPER(ci->defined_class);
ci->me = rb_method_entry_get_with_refinements(Qnil, ci->klass, ci->mid, &ci->defined_class);
}
}
static VALUE
vm_call_general(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci)
{
return vm_call_method(th, reg_cfp, ci);
}

23
vm_insnhelper.h
View file

@ -189,8 +189,8 @@ enum vm_regan_acttype {
} \
} while (0)
#define CALL_METHOD(num, blockptr, flag, id, me, recv, defined_class) do { \
VALUE v = vm_call_method(th, GET_CFP(), (num), (blockptr), (flag), (id), (me), (recv), (defined_class)); \
#define CALL_METHOD(ci) do { \
VALUE v = (*(ci)->call)(th, GET_CFP(), (ci)); \
if (v == Qundef) { \
RESTORE_REGS(); \
NEXT_INSN(); \
@ -235,23 +235,12 @@ enum vm_regan_acttype {
#define USE_IC_FOR_SPECIALIZED_METHOD 1
#endif
#if USE_IC_FOR_SPECIALIZED_METHOD
#define CALL_SIMPLE_METHOD(num, id, recv) do { \
VALUE klass = CLASS_OF(recv), defined_class; \
const rb_method_entry_t *me = vm_method_search((id), klass, ci, &defined_class); \
CALL_METHOD((num), 0, 0, (id), me, (recv), defined_class); \
#define CALL_SIMPLE_METHOD(recv) do { \
ci->blockptr = 0; ci->argc = ci->orig_argc; \
vm_search_method(ci, ci->recv = (recv)); \
CALL_METHOD(ci); \
} while (0)
#else
#define CALL_SIMPLE_METHOD(num, id, recv) do { \
VALUE klass = CLASS_OF(recv); \
CALL_METHOD((num), 0, 0, (id), rb_method_entry(klass, (id)), (recv)); \
} while (0)
#endif
static VALUE ruby_vm_global_state_version = 1;
#define GET_VM_STATE_VERSION() (ruby_vm_global_state_version)