1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* vm_core.h: change iseq parameter data structure.

Browse Source 
https://bugs.ruby-lang.org/issues/10440#change-49694
  * change terminology `arg' to `param'.
  * move rb_iseq_t::arg_* to rb_iseq_t::param.
  * move rb_iseq_t::arg_size to rb_iseq_t::param::size.
  * move rb_iseq_t::argc to rb_iseq_t::param::lead_num.
  * move rb_iseq_t::arg_opts to rb_iseq_t::param::opt_num.
  * move rb_iseq_t::arg_rest to rb_iseq_t::param::rest_start.
  * move rb_iseq_t::arg_post_num to rb_iseq_t::param::post_num.
  * move rb_iseq_t::arg_post_start to rb_iseq_t::param::post_start.
  * move rb_iseq_t::arg_block to rb_iseq_t::param::block_start.
  * move rb_iseq_t::arg_keyword* to rb_iseq_t::param::keyword.
    rb_iseq_t::param::keyword is allocated only when keyword
    parameters are available.
  * introduce rb_iseq_t::param::flags to represent parameter
    availability. For example, rb_iseq_t::param:🎏:has_kw
    represents that this iseq has keyword parameters and
    rb_iseq_t::param::keyword is allocated.
    We don't need to compare with -1 to check availability.
  * remove rb_iseq_t::arg_simple.
* compile.c: catch up this change.
* iseq.c: ditto.
* proc.c: ditto.
* vm.c, vm_args.c, vm_dump.c, vm_insnhelper.c: ditto.
* iseq.c (iseq_data_to_ary): support keyword argument.



git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@48242 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
ko1 2014-11-02 23:14:21 +00:00
parent 5d1f152fa3
commit 831e33c780
9 changed files with 386 additions and 353 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
ChangeLog
View File

@ -1,4 +1,38 @@
Mon Nov 3 03:39:04 2014 Koichi Sasada <ko1@atdot.net> Mon Nov 3 07:49:34 2014 Koichi Sasada <ko1@atdot.net>
* vm_core.h: change iseq parameter data structure.
https://bugs.ruby-lang.org/issues/10440#change-49694
* change terminology `arg' to `param'.
* move rb_iseq_t::arg_* to rb_iseq_t::param.
* move rb_iseq_t::arg_size to rb_iseq_t::param::size.
* move rb_iseq_t::argc to rb_iseq_t::param::lead_num.
* move rb_iseq_t::arg_opts to rb_iseq_t::param::opt_num.
* move rb_iseq_t::arg_rest to rb_iseq_t::param::rest_start.
* move rb_iseq_t::arg_post_num to rb_iseq_t::param::post_num.
* move rb_iseq_t::arg_post_start to rb_iseq_t::param::post_start.
* move rb_iseq_t::arg_block to rb_iseq_t::param::block_start.
* move rb_iseq_t::arg_keyword* to rb_iseq_t::param::keyword.
rb_iseq_t::param::keyword is allocated only when keyword
parameters are available.
* introduce rb_iseq_t::param::flags to represent parameter
availability. For example, rb_iseq_t::param::flags::has_kw
represents that this iseq has keyword parameters and
rb_iseq_t::param::keyword is allocated.
We don't need to compare with -1 to check availability.
* remove rb_iseq_t::arg_simple.
* compile.c: catch up this change.
* iseq.c: ditto.
* proc.c: ditto.
* vm.c, vm_args.c, vm_dump.c, vm_insnhelper.c: ditto.
* iseq.c (iseq_data_to_ary): support keyword argument.
xMon Nov 3 03:39:04 2014 Koichi Sasada <ko1@atdot.net>
* test/ruby/test_method.rb: r48239 makes this test green. * test/ruby/test_method.rb: r48239 makes this test green.

225
compile.c
View File

@ -1076,8 +1076,9 @@ iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)
} }
iseq->argc = (int)args->pre_args_num; iseq->param.lead_num = (int)args->pre_args_num;
debugs(" - argc: %d\n", iseq->argc); if (iseq->param.lead_num > 0) iseq->param.flags.has_lead = TRUE;
debugs(" - argc: %d\n", iseq->param.lead_num);
rest_id = args->rest_arg; rest_id = args->rest_arg;
if (rest_id == 1) { if (rest_id == 1) {
@ -1087,8 +1088,9 @@ iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)
block_id = args->block_arg; block_id = args->block_arg;
if (args->first_post_arg) { if (args->first_post_arg) {
iseq->arg_post_start = get_dyna_var_idx_at_raw(iseq, args->first_post_arg); iseq->param.post_start = get_dyna_var_idx_at_raw(iseq, args->first_post_arg);
iseq->arg_post_num = args->post_args_num; iseq->param.post_num = args->post_args_num;
iseq->param.flags.has_post = TRUE;
} }
if (args->opt_args) { if (args->opt_args) {
@ -1112,16 +1114,15 @@ iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)
ADD_LABEL(optargs, label); ADD_LABEL(optargs, label);
i += 1; i += 1;
iseq->arg_opts = i; iseq->param.opt_num = i;
iseq->arg_opt_table = ALLOC_N(VALUE, i); iseq->param.opt_table = ALLOC_N(VALUE, i);
MEMCPY(iseq->arg_opt_table, RARRAY_CONST_PTR(labels), VALUE, i); MEMCPY(iseq->param.opt_table, RARRAY_CONST_PTR(labels), VALUE, i);
for (j = 0; j < i; j++) { for (j = 0; j < i; j++) {
iseq->arg_opt_table[j] &= ~1; iseq->param.opt_table[j] &= ~1;
} }
rb_ary_clear(labels); rb_ary_clear(labels);
}
else { iseq->param.flags.has_opt = TRUE;
iseq->arg_opts = 0;
} }
if (args->kw_args) { if (args->kw_args) {
@ -1130,7 +1131,9 @@ iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)
const VALUE complex_mark = rb_str_tmp_new(0); const VALUE complex_mark = rb_str_tmp_new(0);
int kw = 0, rkw = 0, di = 0, i; int kw = 0, rkw = 0, di = 0, i;
iseq->arg_keyword_bits = get_dyna_var_idx_at_raw(iseq, args->kw_rest_arg->nd_vid); iseq->param.flags.has_kw = TRUE;
iseq->param.keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
iseq->param.keyword->bits_start = get_dyna_var_idx_at_raw(iseq, args->kw_rest_arg->nd_vid);
while (node) { while (node) {
NODE *val_node = node->nd_body->nd_value; NODE *val_node = node->nd_body->nd_value;
@ -1152,7 +1155,7 @@ iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)
dv = complex_mark; dv = complex_mark;
} }
iseq->arg_keyword_num = ++di; iseq->param.keyword->num = ++di;
rb_ary_push(default_values, dv); rb_ary_push(default_values, dv);
} }
@ -1160,25 +1163,26 @@ iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)
node = node->nd_next; node = node->nd_next;
} }
iseq->arg_keyword_num = kw; iseq->param.keyword->num = kw;
iseq->arg_keyword_rest = args->kw_rest_arg->nd_cflag != 0 ? get_dyna_var_idx_at_raw(iseq, args->kw_rest_arg->nd_cflag) : -1;
iseq->arg_keyword_required = rkw; if (args->kw_rest_arg->nd_cflag != 0) {
iseq->arg_keyword_table = &iseq->local_table[iseq->arg_keyword_bits - iseq->arg_keyword_num]; iseq->param.keyword->rest_start = get_dyna_var_idx_at_raw(iseq, args->kw_rest_arg->nd_cflag);
iseq->arg_keyword_default_values = ALLOC_N(VALUE, RARRAY_LEN(default_values)); iseq->param.flags.has_kwrest = TRUE;
}
iseq->param.keyword->required_num = rkw;
iseq->param.keyword->table = &iseq->local_table[iseq->param.keyword->bits_start - iseq->param.keyword->num];
iseq->param.keyword->default_values = ALLOC_N(VALUE, RARRAY_LEN(default_values));
for (i = 0; i < RARRAY_LEN(default_values); i++) { for (i = 0; i < RARRAY_LEN(default_values); i++) {
VALUE dv = RARRAY_AREF(default_values, i); VALUE dv = RARRAY_AREF(default_values, i);
if (dv == complex_mark) dv = Qundef; if (dv == complex_mark) dv = Qundef;
iseq->arg_keyword_default_values[i] = dv; iseq->param.keyword->default_values[i] = dv;
} }
} }
else if (args->kw_rest_arg) { else if (args->kw_rest_arg) {
iseq->arg_keyword_bits = -1; iseq->param.flags.has_kwrest = TRUE;
iseq->arg_keyword_rest = get_dyna_var_idx_at_raw(iseq, args->kw_rest_arg->nd_vid); iseq->param.keyword = ZALLOC_N(struct rb_iseq_param_keyword, 1);
} iseq->param.keyword->rest_start = get_dyna_var_idx_at_raw(iseq, args->kw_rest_arg->nd_vid);
else {
iseq->arg_keyword_bits = -1;
iseq->arg_keyword_rest = -1;
} }
if (args->pre_init) { /* m_init */ if (args->pre_init) { /* m_init */
@ -1189,76 +1193,67 @@ iseq_set_arguments(rb_iseq_t *iseq, LINK_ANCHOR *optargs, NODE *node_args)
} }
if (rest_id) { if (rest_id) {
iseq->arg_rest = get_dyna_var_idx_at_raw(iseq, rest_id); iseq->param.rest_start = get_dyna_var_idx_at_raw(iseq, rest_id);
iseq->param.flags.has_rest = TRUE;
assert(iseq->param.rest_start != -1);
if (iseq->arg_rest == -1) { if (iseq->param.post_start == 0) { /* TODO: why that? */
rb_bug("arg_rest: -1"); iseq->param.post_start = iseq->param.rest_start + 1;
}
if (iseq->arg_post_start == 0) {
iseq->arg_post_start = iseq->arg_rest + 1;
} }
} }
if (block_id) { if (block_id) {
iseq->arg_block = get_dyna_var_idx_at_raw(iseq, block_id); iseq->param.block_start = get_dyna_var_idx_at_raw(iseq, block_id);
iseq->param.flags.has_block = TRUE;
} }
if (iseq->arg_opts != 0 || if (iseq->param.flags.has_opt ||
iseq->arg_post_num != 0 || iseq->param.flags.has_post ||
iseq->arg_rest != -1 || iseq->param.flags.has_rest ||
iseq->arg_block != -1 || iseq->param.flags.has_block ||
iseq->arg_keyword_bits != -1 || iseq->param.flags.has_kw ||
iseq->arg_keyword_rest != -1) { iseq->param.flags.has_kwrest) {
iseq->arg_simple = 0;
/* set arg_size: size of arguments */ if (iseq->param.flags.has_block) {
if (iseq->arg_block != -1) { iseq->param.size = iseq->param.block_start + 1;
iseq->arg_size = iseq->arg_block + 1;
} }
else if (iseq->arg_keyword_rest != -1) { else if (iseq->param.flags.has_kwrest) {
iseq->arg_size = iseq->arg_keyword_rest + 1; iseq->param.size = iseq->param.keyword->rest_start + 1;
} }
else if (iseq->arg_keyword_bits != -1) { else if (iseq->param.flags.has_kw) {
iseq->arg_size = iseq->arg_keyword_bits + 1; iseq->param.size = iseq->param.keyword->bits_start + 1;
} }
else if (iseq->arg_post_num) { else if (iseq->param.flags.has_post) {
iseq->arg_size = iseq->arg_post_start + iseq->arg_post_num; iseq->param.size = iseq->param.post_start + iseq->param.post_num;
} }
else if (iseq->arg_rest != -1) { else if (iseq->param.flags.has_rest) {
iseq->arg_size = iseq->arg_rest + 1; iseq->param.size = iseq->param.rest_start + 1;
} }
else if (iseq->arg_opts) { else if (iseq->param.flags.has_opt) {
iseq->arg_size = iseq->argc + iseq->arg_opts - 1; iseq->param.size = iseq->param.lead_num + iseq->param.opt_num - 1;
} }
else { else {
iseq->arg_size = iseq->argc; rb_bug("unreachable");
} }
} }
else { else {
iseq->arg_simple = 1; iseq->param.size = iseq->param.lead_num;
iseq->arg_size = iseq->argc;
} }
if (iseq->type == ISEQ_TYPE_BLOCK) { if (iseq->type == ISEQ_TYPE_BLOCK) {
if (iseq->arg_opts == 0 && if (iseq->param.flags.has_opt == FALSE &&
iseq->arg_post_num == 0 && iseq->param.flags.has_post == FALSE &&
iseq->arg_rest == -1 && iseq->param.flags.has_rest == FALSE &&
iseq->arg_keyword_bits == -1 && iseq->param.flags.has_kw == FALSE &&
iseq->arg_keyword_rest == -1) { iseq->param.flags.has_kwrest == FALSE) {
/* TODO: why not check block? */ if (iseq->param.lead_num == 1 && last_comma == 0) {
if (iseq->argc == 1 && last_comma == 0) {
/* {|a|} */ /* {|a|} */
iseq->arg_simple |= 0x02; iseq->param.flags.ambiguous_param0 = TRUE;
} }
} }
} }
} }
else {
iseq->arg_simple = 1;
}
return COMPILE_OK; return COMPILE_OK;
} }
@ -1691,10 +1686,9 @@ iseq_set_optargs_table(rb_iseq_t *iseq)
{ {
int i; int i;
if (iseq->arg_opts != 0) { if (iseq->param.flags.has_opt) {
for (i = 0; i < iseq->arg_opts; i++) { for (i = 0; i < iseq->param.opt_num; i++) {
iseq->arg_opt_table[i] = iseq->param.opt_table[i] = label_get_position((LABEL *)iseq->param.opt_table[i]);
label_get_position((LABEL *)iseq->arg_opt_table[i]);
} }
} }
return COMPILE_OK; return COMPILE_OK;
@ -4490,40 +4484,37 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
rb_iseq_t *liseq = iseq->local_iseq; rb_iseq_t *liseq = iseq->local_iseq;
int lvar_level = get_lvar_level(iseq); int lvar_level = get_lvar_level(iseq);
argc = liseq->argc; argc = liseq->param.lead_num;
/* normal arguments */ /* normal arguments */
for (i = 0; i < liseq->argc; i++) { for (i = 0; i < liseq->param.lead_num; i++) {
int idx = liseq->local_size - i; int idx = liseq->local_size - i;
ADD_INSN2(args, line, getlocal, INT2FIX(idx), INT2FIX(lvar_level)); ADD_INSN2(args, line, getlocal, INT2FIX(idx), INT2FIX(lvar_level));
} }
if (!liseq->arg_simple) { if (liseq->param.flags.has_opt) {
if (liseq->arg_opts) {
/* optional arguments */ /* optional arguments */
int j; int j;
for (j = 0; j < liseq->arg_opts - 1; j++) { for (j = 0; j < liseq->param.opt_num - 1; j++) {
int idx = liseq->local_size - (i + j); int idx = liseq->local_size - (i + j);
ADD_INSN2(args, line, getlocal, INT2FIX(idx), INT2FIX(lvar_level)); ADD_INSN2(args, line, getlocal, INT2FIX(idx), INT2FIX(lvar_level));
} }
i += j; i += j;
argc = i; argc = i;
} }
if (liseq->param.flags.has_rest) {
if (liseq->arg_rest != -1) {
/* rest argument */ /* rest argument */
int idx = liseq->local_size - liseq->arg_rest; int idx = liseq->local_size - liseq->param.rest_start;
ADD_INSN2(args, line, getlocal, INT2FIX(idx), INT2FIX(lvar_level)); ADD_INSN2(args, line, getlocal, INT2FIX(idx), INT2FIX(lvar_level));
argc = liseq->arg_rest + 1; argc = liseq->param.rest_start + 1;
flag |= VM_CALL_ARGS_SPLAT; flag |= VM_CALL_ARGS_SPLAT;
} }
if (liseq->param.flags.has_post) {
if (liseq->arg_post_num > 0) {
/* post arguments */ /* post arguments */
int post_len = liseq->arg_post_num; int post_len = liseq->param.post_num;
int post_start = liseq->arg_post_start; int post_start = liseq->param.post_start;
if (liseq->arg_rest != -1) { if (liseq->param.flags.has_rest) {
int j; int j;
for (j=0; j<post_len; j++) { for (j=0; j<post_len; j++) {
int idx = liseq->local_size - (post_start + j); int idx = liseq->local_size - (post_start + j);
@ -4543,36 +4534,36 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
} }
} }
if (liseq->arg_keyword_bits >= 0) { /* TODO: support keywords */ if (liseq->param.flags.has_kw) { /* TODO: support keywords */
int local_size = liseq->local_size; int local_size = liseq->local_size;
argc++; argc++;
ADD_INSN1(args, line, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE)); ADD_INSN1(args, line, putspecialobject, INT2FIX(VM_SPECIAL_OBJECT_VMCORE));
if (liseq->arg_keyword_rest > 0) { if (liseq->param.flags.has_kwrest) {
ADD_INSN2(args, line, getlocal, INT2FIX(liseq->local_size - liseq->arg_keyword_rest), INT2FIX(lvar_level)); ADD_INSN2(args, line, getlocal, INT2FIX(liseq->local_size - liseq->param.keyword->rest_start), INT2FIX(lvar_level));
ADD_SEND (args, line, rb_intern("dup"), INT2FIX(0)); ADD_SEND (args, line, rb_intern("dup"), INT2FIX(0));
} }
else { else {
ADD_INSN1(args, line, newhash, INT2FIX(0)); ADD_INSN1(args, line, newhash, INT2FIX(0));
} }
for (i = 0; i < liseq->arg_keyword_num; ++i) { for (i = 0; i < liseq->param.keyword->num; ++i) {
ID id = liseq->arg_keyword_table[i]; ID id = liseq->param.keyword->table[i];
int idx = local_size - get_local_var_idx(liseq, id); int idx = local_size - get_local_var_idx(liseq, id);
ADD_INSN1(args, line, putobject, ID2SYM(id)); ADD_INSN1(args, line, putobject, ID2SYM(id));
ADD_INSN2(args, line, getlocal, INT2FIX(idx), INT2FIX(lvar_level)); ADD_INSN2(args, line, getlocal, INT2FIX(idx), INT2FIX(lvar_level));
} }
ADD_SEND(args, line, id_core_hash_merge_ptr, INT2FIX(i * 2 + 1)); ADD_SEND(args, line, id_core_hash_merge_ptr, INT2FIX(i * 2 + 1));
if (liseq->arg_rest != -1) { if (liseq->param.flags.has_rest) {
ADD_INSN1(args, line, newarray, INT2FIX(1)); ADD_INSN1(args, line, newarray, INT2FIX(1));
ADD_INSN (args, line, concatarray); ADD_INSN (args, line, concatarray);
--argc; --argc;
} }
} }
else if (liseq->arg_keyword_rest >= 0) { else if (liseq->param.flags.has_kwrest) {
ADD_INSN2(args, line, getlocal, INT2FIX(liseq->local_size - liseq->arg_keyword_rest), INT2FIX(lvar_level)); ADD_INSN2(args, line, getlocal, INT2FIX(liseq->local_size - liseq->param.keyword->rest_start), INT2FIX(lvar_level));
ADD_SEND (args, line, rb_intern("dup"), INT2FIX(0)); ADD_SEND (args, line, rb_intern("dup"), INT2FIX(0));
if (liseq->arg_rest != -1) { if (liseq->param.flags.has_rest) {
ADD_INSN1(args, line, newarray, INT2FIX(1)); ADD_INSN1(args, line, newarray, INT2FIX(1));
ADD_INSN (args, line, concatarray); ADD_INSN (args, line, concatarray);
} }
@ -4581,7 +4572,6 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
} }
} }
} }
}
/* dummy receiver */ /* dummy receiver */
ADD_INSN1(ret, line, putobject, nd_type(node) == NODE_ZSUPER ? Qfalse : Qtrue); ADD_INSN1(ret, line, putobject, nd_type(node) == NODE_ZSUPER ? Qfalse : Qtrue);
@ -5303,8 +5293,8 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
* kw = default_value * kw = default_value
* end * end
*/ */
int kw_bits_idx = iseq->local_size - iseq->arg_keyword_bits; int kw_bits_idx = iseq->local_size - iseq->param.keyword->bits_start;
int keyword_idx = iseq->arg_keyword_num; int keyword_idx = iseq->param.keyword->num;
ADD_INSN2(ret, line, checkkeyword, INT2FIX(kw_bits_idx), INT2FIX(keyword_idx)); ADD_INSN2(ret, line, checkkeyword, INT2FIX(kw_bits_idx), INT2FIX(keyword_idx));
ADD_INSNL(ret, line, branchif, end_label); ADD_INSNL(ret, line, branchif, end_label);
@ -5889,8 +5879,8 @@ rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE locals, VALUE args,
/* args */ /* args */
if (FIXNUM_P(args)) { if (FIXNUM_P(args)) {
iseq->arg_size = iseq->argc = FIX2INT(args); iseq->param.size = iseq->param.lead_num = FIX2INT(args);
iseq->arg_simple = 1; iseq->param.flags.has_lead = TRUE;
} }
else { else {
int i = 0; int i = 0;
@ -5900,36 +5890,31 @@ rb_iseq_build_from_ary(rb_iseq_t *iseq, VALUE locals, VALUE args,
VALUE arg_post_start = CHECK_INTEGER(rb_ary_entry(args, i++)); VALUE arg_post_start = CHECK_INTEGER(rb_ary_entry(args, i++));
VALUE arg_rest = CHECK_INTEGER(rb_ary_entry(args, i++)); VALUE arg_rest = CHECK_INTEGER(rb_ary_entry(args, i++));
VALUE arg_block = CHECK_INTEGER(rb_ary_entry(args, i++)); VALUE arg_block = CHECK_INTEGER(rb_ary_entry(args, i++));
VALUE arg_simple = CHECK_INTEGER(rb_ary_entry(args, i++));
iseq->argc = FIX2INT(argc); iseq->param.lead_num = FIX2INT(argc);
iseq->arg_rest = FIX2INT(arg_rest); iseq->param.rest_start = FIX2INT(arg_rest);
iseq->arg_post_num = FIX2INT(arg_post_num); iseq->param.post_num = FIX2INT(arg_post_num);
iseq->arg_post_start = FIX2INT(arg_post_start); iseq->param.post_start = FIX2INT(arg_post_start);
iseq->arg_block = FIX2INT(arg_block); iseq->param.block_start = FIX2INT(arg_block);
iseq->arg_opts = RARRAY_LENINT(arg_opt_labels); iseq->param.opt_num = RARRAY_LENINT(arg_opt_labels);
iseq->arg_opt_table = (VALUE *)ALLOC_N(VALUE, iseq->arg_opts); iseq->param.opt_table = (VALUE *)ALLOC_N(VALUE, iseq->param.opt_num);
if (iseq->arg_block != -1) { if (iseq->param.flags.has_block) {
iseq->arg_size = iseq->arg_block + 1; iseq->param.size = iseq->param.block_start + 1;
} }
else if (iseq->arg_post_num) { else if (iseq->param.flags.has_post) {
iseq->arg_size = iseq->arg_post_start + iseq->arg_post_num; iseq->param.size = iseq->param.post_start + iseq->param.post_num;
} }
else if (iseq->arg_rest != -1) { else if (iseq->param.flags.has_rest) {
iseq->arg_size = iseq->arg_rest + 1; iseq->param.size = iseq->param.rest_start + 1;
} }
else { else {
iseq->arg_size = iseq->argc + (iseq->arg_opts ? iseq->arg_opts - 1 : 0); iseq->param.size = iseq->param.lead_num + (iseq->param.opt_num - (iseq->param.flags.has_opt == TRUE));
} }
for (i=0; i<RARRAY_LEN(arg_opt_labels); i++) { for (i=0; i<RARRAY_LEN(arg_opt_labels); i++) {
iseq->arg_opt_table[i] = iseq->param.opt_table[i] = (VALUE)register_label(iseq, labels_table, rb_ary_entry(arg_opt_labels, i));
(VALUE)register_label(iseq, labels_table,
rb_ary_entry(arg_opt_labels, i));
} }
iseq->arg_simple = NUM2INT(arg_simple);
} }
/* exception */ /* exception */

170
iseq.c
View File

@ -23,7 +23,7 @@
#include "insns_info.inc" #include "insns_info.inc"
#define ISEQ_MAJOR_VERSION 2 #define ISEQ_MAJOR_VERSION 2
#define ISEQ_MINOR_VERSION 1 #define ISEQ_MINOR_VERSION 2
VALUE rb_cISeq; VALUE rb_cISeq;
@ -87,7 +87,8 @@ iseq_free(void *ptr)
} }
RUBY_FREE_UNLESS_NULL(iseq->callinfo_entries); RUBY_FREE_UNLESS_NULL(iseq->callinfo_entries);
RUBY_FREE_UNLESS_NULL(iseq->catch_table); RUBY_FREE_UNLESS_NULL(iseq->catch_table);
RUBY_FREE_UNLESS_NULL(iseq->arg_opt_table); RUBY_FREE_UNLESS_NULL(iseq->param.opt_table);
RUBY_FREE_UNLESS_NULL(iseq->param.keyword);
compile_data_free(iseq->compile_data); compile_data_free(iseq->compile_data);
RUBY_FREE_UNLESS_NULL(iseq->iseq); RUBY_FREE_UNLESS_NULL(iseq->iseq);
} }
@ -142,7 +143,7 @@ iseq_memsize(const void *ptr)
if (iseq->catch_table) { if (iseq->catch_table) {
size += iseq_catch_table_bytes(iseq->catch_table->size); size += iseq_catch_table_bytes(iseq->catch_table->size);
} }
size += iseq->arg_opts * sizeof(VALUE); size += iseq->param.opt_num * sizeof(VALUE);
size += iseq->is_size * sizeof(union iseq_inline_storage_entry); size += iseq->is_size * sizeof(union iseq_inline_storage_entry);
size += iseq->callinfo_size * sizeof(rb_call_info_t); size += iseq->callinfo_size * sizeof(rb_call_info_t);
@ -262,32 +263,19 @@ prepare_iseq_build(rb_iseq_t *iseq,
const rb_compile_option_t *option) const rb_compile_option_t *option)
{ {
iseq->type = type; iseq->type = type;
iseq->arg_rest = -1;
iseq->arg_block = -1;
iseq->arg_keyword_bits = -1;
iseq->arg_keyword_rest = -1;
RB_OBJ_WRITE(iseq->self, &iseq->klass, 0); RB_OBJ_WRITE(iseq->self, &iseq->klass, 0);
set_relation(iseq, parent); set_relation(iseq, parent);
name = rb_fstring(name); name = rb_fstring(name);
path = rb_fstring(path); path = rb_fstring(path);
if (RTEST(absolute_path)) if (RTEST(absolute_path)) absolute_path = rb_fstring(absolute_path);
absolute_path = rb_fstring(absolute_path);
iseq_location_setup(iseq, path, absolute_path, name, first_lineno); iseq_location_setup(iseq, path, absolute_path, name, first_lineno);
if (iseq != iseq->local_iseq) { if (iseq != iseq->local_iseq) {
RB_OBJ_WRITE(iseq->self, &iseq->location.base_label, iseq->local_iseq->location.label); RB_OBJ_WRITE(iseq->self, &iseq->location.base_label, iseq->local_iseq->location.label);
} }
iseq->defined_method_id = 0; iseq->defined_method_id = 0;
RB_OBJ_WRITE(iseq->self, &iseq->mark_ary, 0); RB_OBJ_WRITE(iseq->self, &iseq->mark_ary, 0);
/*
* iseq->special_block_builder = GC_GUARDED_PTR_REF(block_opt);
* iseq->cached_special_block_builder = 0;
* iseq->cached_special_block = 0;
*/
iseq->compile_data = ZALLOC(struct iseq_compile_data); iseq->compile_data = ZALLOC(struct iseq_compile_data);
RB_OBJ_WRITE(iseq->self, &iseq->compile_data->err_info, Qnil); RB_OBJ_WRITE(iseq->self, &iseq->compile_data->err_info, Qnil);
RB_OBJ_WRITE(iseq->self, &iseq->compile_data->mark_ary, rb_ary_tmp_new(3)); RB_OBJ_WRITE(iseq->self, &iseq->compile_data->mark_ary, rb_ary_tmp_new(3));
@ -1056,14 +1044,8 @@ VALUE iseq_data_to_ary(rb_iseq_t *iseq);
* An array containing the names of all arguments and local variables as * An array containing the names of all arguments and local variables as
* symbols. * symbols.
* *
* [args] * [params]
* The arity if the method or block only has required arguments. * An Hash object containing parameter information.
*
* Otherwise an array of:
*
* [required_argc, [optional_arg_labels, ...],
* splat_index, post_splat_argc, post_splat_index,
* block_index, simple]
* *
* More info about these values can be found in +vm_core.h+. * More info about these values can be found in +vm_core.h+.
* *
@ -1075,6 +1057,8 @@ VALUE iseq_data_to_ary(rb_iseq_t *iseq);
* An array of arrays containing the instruction names and operands that * An array of arrays containing the instruction names and operands that
* make up the body of the instruction sequence. * make up the body of the instruction sequence.
* *
* Note that this format is MRI specific and version dependent.
*
*/ */
static VALUE static VALUE
iseq_to_a(VALUE self) iseq_to_a(VALUE self)
@ -1384,7 +1368,7 @@ catch_type(int type)
VALUE VALUE
rb_iseq_disasm(VALUE self) rb_iseq_disasm(VALUE self)
{ {
rb_iseq_t *iseqdat = iseq_check(self); rb_iseq_t *iseqdat = iseq_check(self); /* TODO: rename to iseq */
VALUE *iseq; VALUE *iseq;
VALUE str = rb_str_new(0, 0); VALUE str = rb_str_new(0, 0);
VALUE child = rb_ary_new(); VALUE child = rb_ary_new();
@ -1433,13 +1417,16 @@ rb_iseq_disasm(VALUE self)
if (tbl) { if (tbl) {
rb_str_catf(str, rb_str_catf(str,
"local table (size: %d, argc: %d " "local table (size: %d, argc: %d "
"[opts: %d, rest: %d, post: %d, block: %d, kw: %d@%d, kwrest: %d] s%d)\n", "[opts: %d, rest: %d, post: %d, block: %d, kw: %d@%d, kwrest: %d])\n",
iseqdat->local_size, iseqdat->argc, iseqdat->local_size,
iseqdat->arg_opts, iseqdat->arg_rest, iseqdat->param.lead_num,
iseqdat->arg_post_num, iseqdat->arg_block, iseqdat->param.opt_num - (iseqdat->param.flags.has_opt == TRUE),
iseqdat->arg_keyword_num, iseqdat->local_size - iseqdat->arg_keyword_bits, iseqdat->param.flags.has_rest ? iseqdat->param.rest_start : -1,
iseqdat->arg_keyword_rest, iseqdat->param.post_num,
iseqdat->arg_simple); iseqdat->param.flags.has_block ? iseqdat->param.block_start : -1,
iseqdat->param.flags.has_kw ? iseqdat->param.keyword->num : -1,
iseqdat->param.flags.has_kw ? iseqdat->param.keyword->required_num : -1,
iseqdat->param.flags.has_kwrest ? iseqdat->param.keyword->rest_start : -1);
for (i = 0; i < iseqdat->local_table_size; i++) { for (i = 0; i < iseqdat->local_table_size; i++) {
long width; long width;
@ -1447,22 +1434,21 @@ rb_iseq_disasm(VALUE self)
char argi[0x100] = ""; char argi[0x100] = "";
char opti[0x100] = ""; char opti[0x100] = "";
if (iseqdat->arg_opts) { if (iseqdat->param.flags.has_opt) {
int argc = iseqdat->argc; int argc = iseqdat->param.lead_num;
int opts = iseqdat->arg_opts; int opts = iseqdat->param.opt_num;
if (i >= argc && i < argc + opts - 1) { if (i >= argc && i < argc + opts - 1) {
snprintf(opti, sizeof(opti), "Opt=%"PRIdVALUE, snprintf(opti, sizeof(opti), "Opt=%"PRIdVALUE,
iseqdat->arg_opt_table[i - argc]); iseqdat->param.opt_table[i - argc]);
} }
} }
snprintf(argi, sizeof(argi), "%s%s%s%s%s", /* arg, opts, rest, post block */ snprintf(argi, sizeof(argi), "%s%s%s%s%s", /* arg, opts, rest, post block */
iseqdat->argc > i ? "Arg" : "", iseqdat->param.lead_num > i ? "Arg" : "",
opti, opti,
iseqdat->arg_rest == i ? "Rest" : "", (iseqdat->param.flags.has_rest && iseqdat->param.rest_start == i) ? "Rest" : "",
(iseqdat->arg_post_start <= i && (iseqdat->param.flags.has_post && iseqdat->param.post_start <= i && i < iseqdat->param.post_start + iseqdat->param.post_num) ? "Post" : "",
i < iseqdat->arg_post_start + iseqdat->arg_post_num) ? "Post" : "", (iseqdat->param.flags.has_block && iseqdat->param.block_start == i) ? "Block" : "");
iseqdat->arg_block == i ? "Block" : "");
rb_str_catf(str, "[%2d] ", iseqdat->local_size - i); rb_str_catf(str, "[%2d] ", iseqdat->local_size - i);
width = RSTRING_LEN(str) + 11; width = RSTRING_LEN(str) + 11;
@ -1669,7 +1655,7 @@ iseq_data_to_ary(rb_iseq_t *iseq)
VALUE val = rb_ary_new(); VALUE val = rb_ary_new();
VALUE type; /* Symbol */ VALUE type; /* Symbol */
VALUE locals = rb_ary_new(); VALUE locals = rb_ary_new();
VALUE args = rb_ary_new(); VALUE params = rb_hash_new();
VALUE body = rb_ary_new(); /* [[:insn1, ...], ...] */ VALUE body = rb_ary_new(); /* [[:insn1, ...], ...] */
VALUE nbody; VALUE nbody;
VALUE exception = rb_ary_new(); /* [[....]] */ VALUE exception = rb_ary_new(); /* [[....]] */
@ -1729,39 +1715,39 @@ iseq_data_to_ary(rb_iseq_t *iseq)
} }
} }
/* args */ /* params */
{ {
/*
* [argc, # argc
* [label1, label2, ...] # opts
* rest index,
* post_len
* post_start
* block index,
* simple,
* ]
*/
VALUE arg_opt_labels = rb_ary_new(); VALUE arg_opt_labels = rb_ary_new();
int j; int j;
for (j=0; j<iseq->arg_opts; j++) { for (j=0; j<iseq->param.opt_num; j++) {
rb_ary_push(arg_opt_labels, rb_ary_push(arg_opt_labels, register_label(labels_table, iseq->param.opt_table[j]));
register_label(labels_table, iseq->arg_opt_table[j]));
} }
/* commit */ /* commit */
if (iseq->arg_simple == 1) { if (iseq->param.flags.has_lead) rb_hash_aset(params, ID2SYM(rb_intern("lead_num")), INT2FIX(iseq->param.lead_num));
args = INT2FIX(iseq->argc); if (iseq->param.flags.has_opt) rb_hash_aset(params, ID2SYM(rb_intern("opt")), arg_opt_labels);
if (iseq->param.flags.has_post) rb_hash_aset(params, ID2SYM(rb_intern("post_num")), INT2FIX(iseq->param.post_num));
if (iseq->param.flags.has_post) rb_hash_aset(params, ID2SYM(rb_intern("post_start")), INT2FIX(iseq->param.post_start));
if (iseq->param.flags.has_rest) rb_hash_aset(params, ID2SYM(rb_intern("rest_start")), INT2FIX(iseq->param.rest_start));
if (iseq->param.flags.has_block) rb_hash_aset(params, ID2SYM(rb_intern("block_start")), INT2FIX(iseq->param.block_start));
if (iseq->param.flags.has_kw) {
VALUE keywords = rb_ary_new();
int i, j;
for (i=0; i<iseq->param.keyword->required_num; i++) {
rb_ary_push(keywords, ID2SYM(iseq->param.keyword->table[i]));
} }
else { for (j=0; i<iseq->param.keyword->num; i++, j++) {
rb_ary_push(args, INT2FIX(iseq->argc)); VALUE key = rb_ary_new_from_args(1, ID2SYM(iseq->param.keyword->table[i]));
rb_ary_push(args, arg_opt_labels); if (iseq->param.keyword->default_values[j] != Qundef) {
rb_ary_push(args, INT2FIX(iseq->arg_post_num)); rb_ary_push(key, iseq->param.keyword->default_values[j]);
rb_ary_push(args, INT2FIX(iseq->arg_post_start));
rb_ary_push(args, INT2FIX(iseq->arg_rest));
rb_ary_push(args, INT2FIX(iseq->arg_block));
rb_ary_push(args, INT2FIX(iseq->arg_simple));
} }
rb_ary_push(keywords, key);
}
rb_hash_aset(params, ID2SYM(rb_intern("keyword")), keywords);
}
if (iseq->param.flags.has_kwrest) rb_hash_aset(params, ID2SYM(rb_intern("kwrest")), INT2FIX(iseq->param.keyword->rest_start));
if (iseq->param.flags.ambiguous_param0) rb_hash_aset(params, ID2SYM(rb_intern("ambiguous_param0")), Qtrue);
} }
/* body */ /* body */
@ -1897,7 +1883,7 @@ iseq_data_to_ary(rb_iseq_t *iseq)
st_free_table(labels_table); st_free_table(labels_table);
rb_hash_aset(misc, ID2SYM(rb_intern("arg_size")), INT2FIX(iseq->arg_size)); rb_hash_aset(misc, ID2SYM(rb_intern("arg_size")), INT2FIX(iseq->param.size));
rb_hash_aset(misc, ID2SYM(rb_intern("local_size")), INT2FIX(iseq->local_size)); rb_hash_aset(misc, ID2SYM(rb_intern("local_size")), INT2FIX(iseq->local_size));
rb_hash_aset(misc, ID2SYM(rb_intern("stack_max")), INT2FIX(iseq->stack_max)); rb_hash_aset(misc, ID2SYM(rb_intern("stack_max")), INT2FIX(iseq->stack_max));
@ -1918,7 +1904,7 @@ iseq_data_to_ary(rb_iseq_t *iseq)
rb_ary_push(val, iseq->location.first_lineno); rb_ary_push(val, iseq->location.first_lineno);
rb_ary_push(val, type); rb_ary_push(val, type);
rb_ary_push(val, locals); rb_ary_push(val, locals);
rb_ary_push(val, args); rb_ary_push(val, params);
rb_ary_push(val, exception); rb_ary_push(val, exception);
rb_ary_push(val, body); rb_ary_push(val, body);
return val; return val;
@ -1959,7 +1945,7 @@ VALUE
rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc) rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc)
{ {
int i, r; int i, r;
VALUE a, args = rb_ary_new2(iseq->arg_size); VALUE a, args = rb_ary_new2(iseq->param.size);
ID req, opt, rest, block, key, keyrest; ID req, opt, rest, block, key, keyrest;
#define PARAM_TYPE(type) rb_ary_push(a = rb_ary_new2(2), ID2SYM(type)) #define PARAM_TYPE(type) rb_ary_push(a = rb_ary_new2(2), ID2SYM(type))
#define PARAM_ID(i) iseq->local_table[(i)] #define PARAM_ID(i) iseq->local_table[(i)]
@ -1972,18 +1958,18 @@ rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc)
CONST_ID(req, "req"); CONST_ID(req, "req");
CONST_ID(opt, "opt"); CONST_ID(opt, "opt");
if (is_proc) { if (is_proc) {
for (i = 0; i < iseq->argc; i++) { for (i = 0; i < iseq->param.lead_num; i++) {
PARAM_TYPE(opt); PARAM_TYPE(opt);
rb_ary_push(a, rb_id2str(PARAM_ID(i)) ? ID2SYM(PARAM_ID(i)) : Qnil); rb_ary_push(a, rb_id2str(PARAM_ID(i)) ? ID2SYM(PARAM_ID(i)) : Qnil);
rb_ary_push(args, a); rb_ary_push(args, a);
} }
} }
else { else {
for (i = 0; i < iseq->argc; i++) { for (i = 0; i < iseq->param.lead_num; i++) {
rb_ary_push(args, PARAM(i, req)); rb_ary_push(args, PARAM(i, req));
} }
} }
r = iseq->argc + iseq->arg_opts - 1; r = iseq->param.lead_num + iseq->param.opt_num - 1;
for (; i < r; i++) { for (; i < r; i++) {
PARAM_TYPE(opt); PARAM_TYPE(opt);
if (rb_id2str(PARAM_ID(i))) { if (rb_id2str(PARAM_ID(i))) {
@ -1991,52 +1977,52 @@ rb_iseq_parameters(const rb_iseq_t *iseq, int is_proc)
} }
rb_ary_push(args, a); rb_ary_push(args, a);
} }
if (iseq->arg_rest != -1) { if (iseq->param.flags.has_rest) {
CONST_ID(rest, "rest"); CONST_ID(rest, "rest");
rb_ary_push(args, PARAM(iseq->arg_rest, rest)); rb_ary_push(args, PARAM(iseq->param.rest_start, rest));
} }
r = iseq->arg_post_start + iseq->arg_post_num; r = iseq->param.post_start + iseq->param.post_num;
if (is_proc) { if (is_proc) {
for (i = iseq->arg_post_start; i < r; i++) { for (i = iseq->param.post_start; i < r; i++) {
PARAM_TYPE(opt); PARAM_TYPE(opt);
rb_ary_push(a, rb_id2str(PARAM_ID(i)) ? ID2SYM(PARAM_ID(i)) : Qnil); rb_ary_push(a, rb_id2str(PARAM_ID(i)) ? ID2SYM(PARAM_ID(i)) : Qnil);
rb_ary_push(args, a); rb_ary_push(args, a);
} }
} }
else { else {
for (i = iseq->arg_post_start; i < r; i++) { for (i = iseq->param.post_start; i < r; i++) {
rb_ary_push(args, PARAM(i, req)); rb_ary_push(args, PARAM(i, req));
} }
} }
if (iseq->arg_keyword_bits != -1) { if (iseq->param.flags.has_kw) {
i = 0; i = 0;
if (iseq->arg_keyword_required) { if (iseq->param.keyword->required_num > 0) {
ID keyreq; ID keyreq;
CONST_ID(keyreq, "keyreq"); CONST_ID(keyreq, "keyreq");
for (; i < iseq->arg_keyword_required; i++) { for (; i < iseq->param.keyword->required_num; i++) {
PARAM_TYPE(keyreq); PARAM_TYPE(keyreq);
if (rb_id2str(iseq->arg_keyword_table[i])) { if (rb_id2str(iseq->param.keyword->table[i])) {
rb_ary_push(a, ID2SYM(iseq->arg_keyword_table[i])); rb_ary_push(a, ID2SYM(iseq->param.keyword->table[i]));
} }
rb_ary_push(args, a); rb_ary_push(args, a);
} }
} }
CONST_ID(key, "key"); CONST_ID(key, "key");
for (; i < iseq->arg_keyword_num; i++) { for (; i < iseq->param.keyword->num; i++) {
PARAM_TYPE(key); PARAM_TYPE(key);
if (rb_id2str(iseq->arg_keyword_table[i])) { if (rb_id2str(iseq->param.keyword->table[i])) {
rb_ary_push(a, ID2SYM(iseq->arg_keyword_table[i])); rb_ary_push(a, ID2SYM(iseq->param.keyword->table[i]));
} }
rb_ary_push(args, a); rb_ary_push(args, a);
} }
} }
if (iseq->arg_keyword_rest >= 0) { if (iseq->param.flags.has_kwrest) {
CONST_ID(keyrest, "keyrest"); CONST_ID(keyrest, "keyrest");
rb_ary_push(args, PARAM(iseq->arg_keyword_rest, keyrest)); rb_ary_push(args, PARAM(iseq->param.keyword->rest_start, keyrest));
} }
if (iseq->arg_block != -1) { if (iseq->param.flags.has_block) {
CONST_ID(block, "block"); CONST_ID(block, "block");
rb_ary_push(args, PARAM(iseq->arg_block, block)); rb_ary_push(args, PARAM(iseq->param.block_start, block));
} }
return args; return args;
} }
@ -2136,8 +2122,8 @@ rb_iseq_build_for_ruby2cext(
struct iseq_catch_table_entry, iseq->catch_table->size); struct iseq_catch_table_entry, iseq->catch_table->size);
} }
ALLOC_AND_COPY(iseq->arg_opt_table, arg_opt_table, ALLOC_AND_COPY(iseq->param.opt_table, arg_opt_table,
VALUE, iseq->arg_opts); VALUE, iseq->param.opt_num);
set_relation(iseq, 0); set_relation(iseq, 0);

12
proc.c
View File

@ -735,7 +735,7 @@ proc_call(int argc, VALUE *argv, VALUE procval)
GetProcPtr(procval, proc); GetProcPtr(procval, proc);
iseq = proc->block.iseq; iseq = proc->block.iseq;
if (BUILTIN_TYPE(iseq) == T_NODE || iseq->arg_block != -1) { if (BUILTIN_TYPE(iseq) == T_NODE || iseq->param.flags.has_block) {
if (rb_block_given_p()) { if (rb_block_given_p()) {
rb_proc_t *passed_proc; rb_proc_t *passed_proc;
RB_GC_GUARD(passed_procval) = rb_block_proc(); RB_GC_GUARD(passed_procval) = rb_block_proc();
@ -847,11 +847,13 @@ proc_arity(VALUE self)
static inline int static inline int
rb_iseq_min_max_arity(const rb_iseq_t *iseq, int *max) rb_iseq_min_max_arity(const rb_iseq_t *iseq, int *max)
{ {
*max = iseq->arg_rest == -1 ? *max = iseq->param.flags.has_rest == FALSE ?
iseq->argc + iseq->arg_post_num + iseq->arg_opts - iseq->param.lead_num + iseq->param.post_num +
(iseq->arg_opts > 0) + (iseq->arg_keyword_num > 0) + (iseq->arg_keyword_rest >= 0) iseq->param.opt_num - (iseq->param.flags.has_opt == TRUE) +
(iseq->param.flags.has_kw == TRUE) +
(iseq->param.flags.has_kwrest == TRUE)
: UNLIMITED_ARGUMENTS; : UNLIMITED_ARGUMENTS;
return iseq->argc + iseq->arg_post_num + (iseq->arg_keyword_required > 0); return iseq->param.lead_num + iseq->param.post_num + (iseq->param.flags.has_kw && iseq->param.keyword->required_num > 0);
} }
static int static int

2
vm.c
View File

@ -776,7 +776,7 @@ invoke_block_from_c(rb_thread_t *th, const rb_block_t *block,
VALUE ret; VALUE ret;
const rb_iseq_t *iseq = block->iseq; const rb_iseq_t *iseq = block->iseq;
const rb_control_frame_t *cfp; const rb_control_frame_t *cfp;
int i, opt_pc, arg_size = iseq->arg_size; int i, opt_pc, arg_size = iseq->param.size;
int type = block_proc_is_lambda(block->proc) ? VM_FRAME_MAGIC_LAMBDA : VM_FRAME_MAGIC_BLOCK; int type = block_proc_is_lambda(block->proc) ? VM_FRAME_MAGIC_LAMBDA : VM_FRAME_MAGIC_BLOCK;
const rb_method_entry_t *me = th->passed_bmethod_me; const rb_method_entry_t *me = th->passed_bmethod_me;
th->passed_bmethod_me = 0; th->passed_bmethod_me = 0;

60
vm_args.c
View File

@ -381,10 +381,10 @@ static void
args_setup_kw_parameters(VALUE* const passed_values, const int passed_keyword_len, const ID * const passed_keywords, args_setup_kw_parameters(VALUE* const passed_values, const int passed_keyword_len, const ID * const passed_keywords,
const rb_iseq_t * const iseq, VALUE * const locals) const rb_iseq_t * const iseq, VALUE * const locals)
{ {
const ID *acceptable_keywords = iseq->arg_keyword_table; const ID *acceptable_keywords = iseq->param.keyword->table;
const int req_key_num = iseq->arg_keyword_required; const int req_key_num = iseq->param.keyword->required_num;
const int key_num = iseq->arg_keyword_num; const int key_num = iseq->param.keyword->num;
const VALUE * const default_values = iseq->arg_keyword_default_values; const VALUE * const default_values = iseq->param.keyword->default_values;
VALUE missing = 0; VALUE missing = 0;
int i, di, found = 0; int i, di, found = 0;
int unspecified_bits = 0; int unspecified_bits = 0;
@ -435,7 +435,7 @@ args_setup_kw_parameters(VALUE* const passed_values, const int passed_keyword_le
} }
} }
if (iseq->arg_keyword_rest >= 0) { if (iseq->param.flags.has_kwrest) {
const int rest_hash_index = key_num + 1; const int rest_hash_index = key_num + 1;
locals[rest_hash_index] = make_unused_kw_hash(passed_keywords, passed_keyword_len, passed_values, FALSE); locals[rest_hash_index] = make_unused_kw_hash(passed_keywords, passed_keyword_len, passed_values, FALSE);
} }
@ -522,13 +522,13 @@ static int
setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, rb_call_info_t * const ci, setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, rb_call_info_t * const ci,
VALUE * const locals, const enum arg_setup_type arg_setup_type) VALUE * const locals, const enum arg_setup_type arg_setup_type)
{ {
const int min_argc = iseq->argc + iseq->arg_post_num; const int min_argc = iseq->param.lead_num + iseq->param.post_num;
const int max_argc = (iseq->arg_rest == -1) ? min_argc + (iseq->arg_opts - (iseq->arg_opts > 0)) : UNLIMITED_ARGUMENTS; const int max_argc = (iseq->param.flags.has_rest == FALSE) ? min_argc + (iseq->param.opt_num - (iseq->param.flags.has_opt == TRUE)) : UNLIMITED_ARGUMENTS;
int opt_pc = 0; int opt_pc = 0;
int given_argc; int given_argc;
struct args_info args_body, *args; struct args_info args_body, *args;
VALUE keyword_hash = Qnil; VALUE keyword_hash = Qnil;
const int msl = ci->argc + iseq->arg_size; const int msl = ci->argc + iseq->param.size;
th->mark_stack_len = msl; th->mark_stack_len = msl;
@ -539,7 +539,7 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
args->argv = locals; args->argv = locals;
if (ci->kw_arg) { if (ci->kw_arg) {
if (iseq->arg_keyword_bits >= 0) { if (iseq->param.flags.has_kw) {
int kw_len = ci->kw_arg->keyword_len; int kw_len = ci->kw_arg->keyword_len;
/* copy kw_argv */ /* copy kw_argv */
args->kw_argv = ALLOCA_N(VALUE, kw_len); args->kw_argv = ALLOCA_N(VALUE, kw_len);
@ -571,16 +571,16 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
case arg_setup_block: case arg_setup_block:
if (given_argc == 1 && if (given_argc == 1 &&
(min_argc > 0 || (min_argc > 0 ||
iseq->arg_opts > 2 || iseq->arg_keyword_bits >= 0 || iseq->arg_keyword_rest >= 0) && /* TODO: can be shrink with flags */ iseq->param.opt_num > 2 || iseq->param.flags.has_kw || iseq->param.flags.has_kwrest) && /* TODO: can be shrink with flags */
!(iseq->arg_simple & 0x02) && !iseq->param.flags.ambiguous_param0 &&
args_check_block_arg0(args, th, msl)) { args_check_block_arg0(args, th, msl)) {
given_argc = RARRAY_LEN(args->rest); given_argc = RARRAY_LEN(args->rest);
} }
break; break;
case arg_setup_lambda: case arg_setup_lambda:
if (given_argc == 1 && if (given_argc == 1 &&
given_argc != iseq->argc && given_argc != iseq->param.lead_num &&
!(iseq->arg_rest >= 0) && !iseq->param.flags.has_rest &&
args_check_block_arg0(args, th, msl)) { args_check_block_arg0(args, th, msl)) {
given_argc = RARRAY_LEN(args->rest); given_argc = RARRAY_LEN(args->rest);
} }
@ -605,7 +605,7 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
} }
if (given_argc > min_argc && if (given_argc > min_argc &&
(iseq->arg_keyword_bits >= 0 || iseq->arg_keyword_rest >= 0) && (iseq->param.flags.has_kw || iseq->param.flags.has_kwrest) &&
args->kw_argv == NULL) { args->kw_argv == NULL) {
if (args_pop_keyword_hash(args, &keyword_hash, th, msl)) { if (args_pop_keyword_hash(args, &keyword_hash, th, msl)) {
given_argc--; given_argc--;
@ -623,25 +623,25 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
} }
} }
if (iseq->argc > 0) { if (iseq->param.flags.has_lead) {
args_setup_lead_parameters(args, iseq->argc, locals + 0); args_setup_lead_parameters(args, iseq->param.lead_num, locals + 0);
} }
if (iseq->arg_post_num > 0) { if (iseq->param.flags.has_post) {
args_setup_post_parameters(args, iseq->arg_post_num, locals + iseq->arg_post_start); args_setup_post_parameters(args, iseq->param.post_num, locals + iseq->param.post_start);
} }
if (iseq->arg_opts > 0) { if (iseq->param.flags.has_opt) {
int opt = args_setup_opt_parameters(args, iseq->arg_opts - 1, locals + iseq->argc); int opt = args_setup_opt_parameters(args, iseq->param.opt_num - 1, locals + iseq->param.lead_num);
opt_pc = (int)iseq->arg_opt_table[opt]; opt_pc = (int)iseq->param.opt_table[opt];
} }
if (iseq->arg_rest >= 0) { if (iseq->param.flags.has_rest) {
args_setup_rest_parameter(args, locals + iseq->arg_rest); args_setup_rest_parameter(args, locals + iseq->param.rest_start);
} }
if (iseq->arg_keyword_bits >= 0) { if (iseq->param.flags.has_kw) {
VALUE * const klocals = locals + iseq->arg_keyword_bits - iseq->arg_keyword_num; VALUE * const klocals = locals + iseq->param.keyword->bits_start - iseq->param.keyword->num;
if (args->kw_argv != NULL) { if (args->kw_argv != NULL) {
args_setup_kw_parameters(args->kw_argv, args->ci->kw_arg->keyword_len, args->ci->kw_arg->keywords, iseq, klocals); args_setup_kw_parameters(args->kw_argv, args->ci->kw_arg->keyword_len, args->ci->kw_arg->keywords, iseq, klocals);
@ -662,18 +662,18 @@ setup_parameters_complex(rb_thread_t * const th, const rb_iseq_t * const iseq, r
args_setup_kw_parameters(NULL, 0, NULL, iseq, klocals); args_setup_kw_parameters(NULL, 0, NULL, iseq, klocals);
} }
} }
else if (iseq->arg_keyword_rest >= 0) { else if (iseq->param.flags.has_kwrest) {
args_setup_kw_rest_parameter(keyword_hash, locals + iseq->arg_keyword_rest); args_setup_kw_rest_parameter(keyword_hash, locals + iseq->param.keyword->rest_start);
} }
if (iseq->arg_block >= 0) { if (iseq->param.flags.has_block) {
args_setup_block_parameter(th, ci, locals + iseq->arg_block); args_setup_block_parameter(th, ci, locals + iseq->param.block_start);
} }
#if 0 #if 0
{ {
int i; int i;
for (i=0; i<iseq->arg_size; i++) { for (i=0; i<iseq->param.size; i++) {
fprintf(stderr, "local[%d] = %p\n", i, (void *)locals[i]); fprintf(stderr, "local[%d] = %p\n", i, (void *)locals[i]);
} }
} }

72
vm_core.h
View File

@ -240,7 +240,7 @@ struct rb_iseq_struct {
rb_call_info_t *callinfo_entries; rb_call_info_t *callinfo_entries;
/** /**
* argument information * parameter information
* *
* def m(a1, a2, ..., aM, # mandatory * def m(a1, a2, ..., aM, # mandatory
* b1=(...), b2=(...), ..., bN=(...), # optional * b1=(...), b2=(...), ..., bN=(...), # optional
@ -251,36 +251,50 @@ struct rb_iseq_struct {
* &g) # block * &g) # block
* => * =>
* *
* argc = M // or 0 if no mandatory arg * lead_num = M
* arg_opts = N+1 // or 0 if no optional arg * opt_num = N+1
* arg_rest = M+N // or -1 if no rest arg * rest_start = M+N
* arg_opt_table = [ (arg_opts entries) ] * post_start = M+N+(*1)
* arg_post_start = M+N+(*1) // or 0 if no post arguments * post_num = O
* arg_post_num = O // or 0 if no post arguments * keyword_num = K
* arg_keyword_num = K // or 0 if no keyword arg * block_start = M+N+(*1)+O+K
* arg_block = M+N+(*1)+O+K // or -1 if no block arg * keyword_bits = M+N+(*1)+O+K+(&1)
* arg_keyword_bits = M+N+(*1)+O+K+(&1) // or -1 if no keyword arg/rest * size = M+N+O+(*1)+K+(&1)+(**1) // parameter size.
* arg_simple = 0 if not simple arguments.
* = 1 if no opt, rest, post, block.
* = 2 if ambiguous block parameter ({|a|}).
* arg_size = M+N+O+(*1)+K+(&1)+(**1) argument size.
*/ */
int argc; struct {
int arg_simple; struct {
int arg_rest; unsigned int has_lead : 1;
int arg_block; unsigned int has_opt : 1;
int arg_opts; unsigned int has_rest : 1;
int arg_post_num; unsigned int has_post : 1;
int arg_post_start; unsigned int has_kw : 1;
int arg_size; unsigned int has_kwrest : 1;
VALUE *arg_opt_table; unsigned int has_block : 1;
int arg_keyword_num;
int arg_keyword_bits; unsigned int ambiguous_param0 : 1; /* {|a|} */
int arg_keyword_rest; } flags;
int arg_keyword_required;
ID *arg_keyword_table; int size;
VALUE *arg_keyword_default_values;
int lead_num;
int opt_num;
int rest_start;
int post_start;
int post_num;
int block_start;
VALUE *opt_table;
struct rb_iseq_param_keyword {
int num;
int required_num;
int bits_start;
int rest_start;
ID *table;
VALUE *default_values;
} *keyword;
} param;
/* catch table */ /* catch table */
struct iseq_catch_table *catch_table; struct iseq_catch_table *catch_table;

2
vm_dump.c
View File

@ -265,7 +265,7 @@ vm_stack_dump_each(rb_thread_t *th, rb_control_frame_t *cfp)
name = "<ifunc>"; name = "<ifunc>";
} }
else { else {
argc = iseq->argc; argc = iseq->param.lead_num;
local_size = iseq->local_size; local_size = iseq->local_size;
name = RSTRING_PTR(iseq->location.label); name = RSTRING_PTR(iseq->location.label);
} }

54
vm_insnhelper.c
View File

@ -1008,19 +1008,30 @@ vm_callee_setup_block_arg_arg0_splat(rb_control_frame_t *cfp, const rb_iseq_t *i
int i; int i;
long len = RARRAY_LEN(ary); long len = RARRAY_LEN(ary);
CHECK_VM_STACK_OVERFLOW(cfp, iseq->argc); CHECK_VM_STACK_OVERFLOW(cfp, iseq->param.lead_num);
for (i=0; i<len && i<iseq->argc; i++) { for (i=0; i<len && i<iseq->param.lead_num; i++) {
argv[i] = RARRAY_AREF(ary, i); argv[i] = RARRAY_AREF(ary, i);
} }
return i; return i;
} }
static inline int
simple_iseq_p(const rb_iseq_t *iseq)
{
return iseq->param.flags.has_opt == FALSE &&
iseq->param.flags.has_rest == FALSE &&
iseq->param.flags.has_post == FALSE &&
iseq->param.flags.has_kw == FALSE &&
iseq->param.flags.has_kwrest == FALSE &&
iseq->param.flags.has_block == FALSE;
}
static inline void static inline void
vm_callee_setup_block_arg(rb_thread_t *th, rb_call_info_t *ci, const rb_iseq_t *iseq, VALUE *argv, const enum arg_setup_type arg_setup_type) vm_callee_setup_block_arg(rb_thread_t *th, rb_call_info_t *ci, const rb_iseq_t *iseq, VALUE *argv, const enum arg_setup_type arg_setup_type)
{ {
if (LIKELY(iseq->arg_simple & 0x01)) { if (LIKELY(simple_iseq_p(iseq))) {
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
VALUE arg0; VALUE arg0;
@ -1028,31 +1039,32 @@ vm_callee_setup_block_arg(rb_thread_t *th, rb_call_info_t *ci, const rb_iseq_t *
if (arg_setup_type == arg_setup_block && if (arg_setup_type == arg_setup_block &&
ci->argc == 1 && ci->argc == 1 &&
iseq->argc > 0 && !(iseq->arg_simple & 0x02) && iseq->param.flags.has_lead &&
!iseq->param.flags.ambiguous_param0 &&
!NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv))) { !NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv))) {
ci->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0); ci->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0);
} }
if (ci->argc != iseq->argc) { if (ci->argc != iseq->param.lead_num) {
if (arg_setup_type == arg_setup_block) { if (arg_setup_type == arg_setup_block) {
if (ci->argc < iseq->argc) { if (ci->argc < iseq->param.lead_num) {
int i; int i;
CHECK_VM_STACK_OVERFLOW(cfp, iseq->argc); CHECK_VM_STACK_OVERFLOW(cfp, iseq->param.lead_num);
for (i=ci->argc; i<iseq->argc; i++) argv[i] = Qnil; for (i=ci->argc; i<iseq->param.lead_num; i++) argv[i] = Qnil;
ci->argc = iseq->argc; /* fill rest parameters */ ci->argc = iseq->param.lead_num; /* fill rest parameters */
} }
else if (ci->argc > iseq->argc) { else if (ci->argc > iseq->param.lead_num) {
ci->argc = iseq->argc; /* simply truncate arguments */ ci->argc = iseq->param.lead_num; /* simply truncate arguments */
} }
} }
else if (arg_setup_type == arg_setup_lambda && else if (arg_setup_type == arg_setup_lambda &&
ci->argc == 1 && ci->argc == 1 &&
!NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv)) && !NIL_P(arg0 = vm_callee_setup_block_arg_arg0_check(argv)) &&
RARRAY_LEN(arg0) == iseq->argc) { RARRAY_LEN(arg0) == iseq->param.lead_num) {
ci->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0); ci->argc = vm_callee_setup_block_arg_arg0_splat(cfp, iseq, argv, arg0);
} }
else { else {
argument_error(iseq, ci->argc, iseq->argc, iseq->argc); argument_error(iseq, ci->argc, iseq->param.lead_num, iseq->param.lead_num);
} }
} }
@ -1066,13 +1078,13 @@ vm_callee_setup_block_arg(rb_thread_t *th, rb_call_info_t *ci, const rb_iseq_t *
static inline void static inline void
vm_callee_setup_arg(rb_thread_t *th, rb_call_info_t *ci, const rb_iseq_t *iseq, VALUE *argv) vm_callee_setup_arg(rb_thread_t *th, rb_call_info_t *ci, const rb_iseq_t *iseq, VALUE *argv)
{ {
if (LIKELY(iseq->arg_simple & 0x01)) { if (LIKELY(simple_iseq_p(iseq))) {
rb_control_frame_t *cfp = th->cfp; rb_control_frame_t *cfp = th->cfp;
CALLER_SETUP_ARG(cfp, ci); /* splat arg */ CALLER_SETUP_ARG(cfp, ci); /* splat arg */
if (ci->argc != iseq->argc) { if (ci->argc != iseq->param.lead_num) {
argument_error(iseq, ci->argc, iseq->argc, iseq->argc); argument_error(iseq, ci->argc, iseq->param.lead_num, iseq->param.lead_num);
} }
ci->aux.opt_pc = 0; ci->aux.opt_pc = 0;
@ -1110,10 +1122,10 @@ vm_call_iseq_setup_normal(rb_thread_t *th, rb_control_frame_t *cfp, rb_call_info
int i, local_size; int i, local_size;
VALUE *argv = cfp->sp - ci->argc; VALUE *argv = cfp->sp - ci->argc;
rb_iseq_t *iseq = ci->me->def->body.iseq; rb_iseq_t *iseq = ci->me->def->body.iseq;
VALUE *sp = argv + iseq->arg_size; VALUE *sp = argv + iseq->param.size;
/* clear local variables (arg_size...local_size) */ /* clear local variables (arg_size...local_size) */
for (i = iseq->arg_size, local_size = iseq->local_size; i < local_size; i++) { for (i = iseq->param.size, local_size = iseq->local_size; i < local_size; i++) {
*sp++ = Qnil; *sp++ = Qnil;
} }
@ -1146,12 +1158,12 @@ vm_call_iseq_setup_tailcall(rb_thread_t *th, rb_control_frame_t *cfp, rb_call_in
sp++; sp++;
/* copy arguments */ /* copy arguments */
for (i=0; i < iseq->arg_size; i++) { for (i=0; i < iseq->param.size; i++) {
*sp++ = src_argv[i]; *sp++ = src_argv[i];
} }
/* clear local variables */ /* clear local variables */
for (i = 0; i < iseq->local_size - iseq->arg_size; i++) { for (i = 0; i < iseq->local_size - iseq->param.size; i++) {
*sp++ = Qnil; *sp++ = Qnil;
} }
@ -2031,7 +2043,7 @@ vm_invoke_block(rb_thread_t *th, rb_control_frame_t *reg_cfp, rb_call_info_t *ci
if (BUILTIN_TYPE(iseq) != T_NODE) { if (BUILTIN_TYPE(iseq) != T_NODE) {
int opt_pc; int opt_pc;
const int arg_size = iseq->arg_size; const int arg_size = iseq->param.size;
int is_lambda = block_proc_is_lambda(block->proc); int is_lambda = block_proc_is_lambda(block->proc);
VALUE * const rsp = GET_SP() - ci->argc; VALUE * const rsp = GET_SP() - ci->argc;