diff options
Diffstat (limited to 'vm_args.c')
| -rw-r--r-- | vm_args.c | 1315 |
1 files changed, 797 insertions, 518 deletions
@@ -1,6 +1,6 @@ /********************************************************************** - vm_args.c - process method call arguments. + vm_args.c - process method call arguments. Included into vm.c. $Author$ @@ -8,12 +8,13 @@ **********************************************************************/ -NORETURN(static void raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const VALUE exc)); -NORETURN(static void argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const int miss_argc, const int min_argc, const int max_argc)); -NORETURN(static void argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const char *error, const VALUE keys)); +NORETURN(static void raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const VALUE exc)); +NORETURN(static void argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const int miss_argc, const int min_argc, const int max_argc)); +NORETURN(static void argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const char *error, const VALUE keys)); VALUE rb_keyword_error_new(const char *error, VALUE keys); /* class.c */ -static VALUE method_missing(VALUE obj, ID id, int argc, const VALUE *argv, - enum method_missing_reason call_status); +static VALUE method_missing(rb_execution_context_t *ec, VALUE obj, ID id, int argc, const VALUE *argv, + enum method_missing_reason call_status, int kw_splat); +const rb_callable_method_entry_t *rb_resolve_refined_method_callable(VALUE refinements, const rb_callable_method_entry_t *me); struct args_info { /* basic args info */ @@ -23,7 +24,7 @@ struct args_info { /* additional args info */ int rest_index; int rest_dupped; - const struct rb_call_info_kw_arg *kw_arg; + const struct rb_callinfo_kwarg *kw_arg; VALUE *kw_argv; VALUE rest; }; @@ -46,10 +47,10 @@ static inline int args_argc(struct args_info *args) { if (args->rest == Qfalse) { - return args->argc; + return args->argc; } else { - return args->argc + RARRAY_LENINT(args->rest) - args->rest_index; + return args->argc + RARRAY_LENINT(args->rest) - args->rest_index; } } @@ -60,15 +61,15 @@ args_extend(struct args_info *args, const int min_argc) if (args->rest) { arg_rest_dup(args); - VM_ASSERT(args->rest_index == 0); - for (i=args->argc + RARRAY_LENINT(args->rest); i<min_argc; i++) { - rb_ary_push(args->rest, Qnil); - } + VM_ASSERT(args->rest_index == 0); + for (i=args->argc + RARRAY_LENINT(args->rest); i<min_argc; i++) { + rb_ary_push(args->rest, Qnil); + } } else { - for (i=args->argc; i<min_argc; i++) { - args->argv[args->argc++] = Qnil; - } + for (i=args->argc; i<min_argc; i++) { + args->argv[args->argc++] = Qnil; + } } } @@ -76,17 +77,17 @@ static inline void args_reduce(struct args_info *args, int over_argc) { if (args->rest) { - const long len = RARRAY_LEN(args->rest); + const long len = RARRAY_LEN(args->rest); - if (len > over_argc) { - arg_rest_dup(args); - rb_ary_resize(args->rest, len - over_argc); - return; - } - else { - args->rest = Qfalse; - over_argc -= len; - } + if (len > over_argc) { + arg_rest_dup(args); + rb_ary_resize(args->rest, len - over_argc); + return; + } + else { + args->rest = Qfalse; + over_argc -= len; + } } VM_ASSERT(args->argc >= over_argc); @@ -99,20 +100,20 @@ args_check_block_arg0(struct args_info *args) VALUE ary = Qnil; if (args->rest && RARRAY_LEN(args->rest) == 1) { - VALUE arg0 = RARRAY_AREF(args->rest, 0); - ary = rb_check_array_type(arg0); + VALUE arg0 = RARRAY_AREF(args->rest, 0); + ary = rb_check_array_type(arg0); } else if (args->argc == 1) { - VALUE arg0 = args->argv[0]; - ary = rb_check_array_type(arg0); - args->argv[0] = arg0; /* see: https://bugs.ruby-lang.org/issues/8484 */ + VALUE arg0 = args->argv[0]; + ary = rb_check_array_type(arg0); + args->argv[0] = arg0; /* see: https://bugs.ruby-lang.org/issues/8484 */ } if (!NIL_P(ary)) { - args->rest = ary; - args->rest_index = 0; - args->argc = 0; - return TRUE; + args->rest = ary; + args->rest_index = 0; + args->argc = 0; + return TRUE; } return FALSE; @@ -122,49 +123,49 @@ static inline void args_copy(struct args_info *args) { if (args->rest != Qfalse) { - int argc = args->argc; - args->argc = 0; + int argc = args->argc; + args->argc = 0; arg_rest_dup(args); - /* - * argv: [m0, m1, m2, m3] - * rest: [a0, a1, a2, a3, a4, a5] - * ^ - * rest_index - * - * #=> first loop - * - * argv: [m0, m1] - * rest: [m2, m3, a2, a3, a4, a5] - * ^ - * rest_index - * - * #=> 2nd loop - * - * argv: [] (argc == 0) - * rest: [m0, m1, m2, m3, a2, a3, a4, a5] - * ^ - * rest_index - */ - while (args->rest_index > 0 && argc > 0) { - RARRAY_ASET(args->rest, --args->rest_index, args->argv[--argc]); - } - while (argc > 0) { - rb_ary_unshift(args->rest, args->argv[--argc]); - } + /* + * argv: [m0, m1, m2, m3] + * rest: [a0, a1, a2, a3, a4, a5] + * ^ + * rest_index + * + * #=> first loop + * + * argv: [m0, m1] + * rest: [m2, m3, a2, a3, a4, a5] + * ^ + * rest_index + * + * #=> 2nd loop + * + * argv: [] (argc == 0) + * rest: [m0, m1, m2, m3, a2, a3, a4, a5] + * ^ + * rest_index + */ + while (args->rest_index > 0 && argc > 0) { + RARRAY_ASET(args->rest, --args->rest_index, args->argv[--argc]); + } + while (argc > 0) { + rb_ary_unshift(args->rest, args->argv[--argc]); + } } else if (args->argc > 0) { - args->rest = rb_ary_new_from_values(args->argc, args->argv); - args->rest_index = 0; + args->rest = rb_ary_new_from_values(args->argc, args->argv); + args->rest_index = 0; args->rest_dupped = TRUE; - args->argc = 0; + args->argc = 0; } } static inline const VALUE * args_rest_argv(struct args_info *args) { - return RARRAY_CONST_PTR_TRANSIENT(args->rest) + args->rest_index; + return RARRAY_CONST_PTR(args->rest) + args->rest_index; } static inline VALUE @@ -175,80 +176,18 @@ args_rest_array(struct args_info *args) if (args->rest) { ary = rb_ary_behead(args->rest, args->rest_index); args->rest_index = 0; - args->rest = 0; + args->rest = 0; } else { - ary = rb_ary_new(); + ary = rb_ary_new(); } return ary; } static int -keyword_hash_p(VALUE *kw_hash_ptr, VALUE *rest_hash_ptr) -{ - *rest_hash_ptr = rb_check_hash_type(*kw_hash_ptr); - - if (!NIL_P(*rest_hash_ptr)) { - VALUE hash = rb_extract_keywords(rest_hash_ptr); - if (!hash) hash = Qnil; - *kw_hash_ptr = hash; - return TRUE; - } - else { - *kw_hash_ptr = Qnil; - return FALSE; - } -} - -static VALUE -args_pop_keyword_hash(struct args_info *args, VALUE *kw_hash_ptr) -{ - VALUE rest_hash; - - if (args->rest == Qfalse) { - from_argv: - VM_ASSERT(args->argc > 0); - *kw_hash_ptr = args->argv[args->argc-1]; - - if (keyword_hash_p(kw_hash_ptr, &rest_hash)) { - if (rest_hash) { - args->argv[args->argc-1] = rest_hash; - } - else { - args->argc--; - return TRUE; - } - } - } - else { - long len = RARRAY_LEN(args->rest); - - if (len > 0) { - *kw_hash_ptr = RARRAY_AREF(args->rest, len - 1); - - if (keyword_hash_p(kw_hash_ptr, &rest_hash)) { - if (rest_hash) { - RARRAY_ASET(args->rest, len - 1, rest_hash); - } - else { - arg_rest_dup(args); - rb_ary_pop(args->rest); - return TRUE; - } - } - } - else { - goto from_argv; - } - } - - return FALSE; -} - -static int args_kw_argv_to_hash(struct args_info *args) { - const struct rb_call_info_kw_arg *kw_arg = args->kw_arg; + const struct rb_callinfo_kwarg *kw_arg = args->kw_arg; const VALUE *const passed_keywords = kw_arg->keywords; const int kw_len = kw_arg->keyword_len; VALUE h = rb_hash_new_with_size(kw_len); @@ -258,7 +197,7 @@ args_kw_argv_to_hash(struct args_info *args) args->argc = kw_start + 1; for (i=0; i<kw_len; i++) { - rb_hash_aset(h, passed_keywords[i], kw_argv[i]); + rb_hash_aset(h, passed_keywords[i], kw_argv[i]); } args->argv[args->argc - 1] = h; @@ -266,46 +205,23 @@ args_kw_argv_to_hash(struct args_info *args) return args->argc; } -static void -args_stored_kw_argv_to_hash(struct args_info *args) -{ - int i; - const struct rb_call_info_kw_arg *kw_arg = args->kw_arg; - const VALUE *const passed_keywords = kw_arg->keywords; - const int passed_keyword_len = kw_arg->keyword_len; - VALUE h = rb_hash_new_with_size(passed_keyword_len); - - for (i=0; i<passed_keyword_len; i++) { - rb_hash_aset(h, passed_keywords[i], args->kw_argv[i]); - } - args->kw_argv = NULL; - - if (args->rest) { - arg_rest_dup(args); - rb_ary_push(args->rest, h); - } - else { - args->argv[args->argc++] = h; - } -} - static inline void args_setup_lead_parameters(struct args_info *args, int argc, VALUE *locals) { if (args->argc >= argc) { - /* do noting */ - args->argc -= argc; - args->argv += argc; + /* do noting */ + args->argc -= argc; + args->argv += argc; } else { - int i, j; - const VALUE *argv = args_rest_argv(args); + int i, j; + const VALUE *argv = args_rest_argv(args); - for (i=args->argc, j=0; i<argc; i++, j++) { - locals[i] = argv[j]; - } - args->rest_index += argc - args->argc; - args->argc = 0; + for (i=args->argc, j=0; i<argc; i++, j++) { + locals[i] = argv[j]; + } + args->rest_index += argc - args->argc; + args->argc = 0; } } @@ -314,7 +230,7 @@ args_setup_post_parameters(struct args_info *args, int argc, VALUE *locals) { long len; len = RARRAY_LEN(args->rest); - MEMCPY(locals, RARRAY_CONST_PTR_TRANSIENT(args->rest) + len - argc, VALUE, argc); + MEMCPY(locals, RARRAY_CONST_PTR(args->rest) + len - argc, VALUE, argc); rb_ary_resize(args->rest, len - argc); } @@ -324,28 +240,22 @@ args_setup_opt_parameters(struct args_info *args, int opt_max, VALUE *locals) int i; if (args->argc >= opt_max) { - args->argc -= opt_max; - args->argv += opt_max; - i = opt_max; + args->argc -= opt_max; + args->argv += opt_max; + i = opt_max; } else { - int j; - i = args->argc; - args->argc = 0; + i = args->argc; + args->argc = 0; - if (args->rest) { + if (args->rest) { int len = RARRAY_LENINT(args->rest); - const VALUE *argv = RARRAY_CONST_PTR_TRANSIENT(args->rest); + const VALUE *argv = RARRAY_CONST_PTR(args->rest); for (; i<opt_max && args->rest_index < len; i++, args->rest_index++) { locals[i] = argv[args->rest_index]; } } - - /* initialize by nil */ - for (j=i; j<opt_max; j++) { - locals[j] = Qnil; - } } return i; @@ -361,12 +271,12 @@ static VALUE make_unknown_kw_hash(const VALUE *passed_keywords, int passed_keyword_len, const VALUE *kw_argv) { int i; - VALUE obj = rb_ary_tmp_new(1); + VALUE obj = rb_ary_hidden_new(1); for (i=0; i<passed_keyword_len; i++) { - if (kw_argv[i] != Qundef) { - rb_ary_push(obj, passed_keywords[i]); - } + if (!UNDEF_P(kw_argv[i])) { + rb_ary_push(obj, passed_keywords[i]); + } } return obj; } @@ -378,9 +288,9 @@ make_rest_kw_hash(const VALUE *passed_keywords, int passed_keyword_len, const VA VALUE obj = rb_hash_new_with_size(passed_keyword_len); for (i=0; i<passed_keyword_len; i++) { - if (kw_argv[i] != Qundef) { - rb_hash_aset(obj, passed_keywords[i], kw_argv[i]); - } + if (!UNDEF_P(kw_argv[i])) { + rb_hash_aset(obj, passed_keywords[i], kw_argv[i]); + } } return obj; } @@ -392,98 +302,207 @@ args_setup_kw_parameters_lookup(const ID key, VALUE *ptr, const VALUE *const pas const VALUE keyname = ID2SYM(key); for (i=0; i<passed_keyword_len; i++) { - if (keyname == passed_keywords[i]) { - *ptr = passed_values[i]; - passed_values[i] = Qundef; - return TRUE; - } + if (keyname == passed_keywords[i]) { + *ptr = passed_values[i]; + passed_values[i] = Qundef; + return TRUE; + } } return FALSE; } -#define KW_SPECIFIED_BITS_MAX (32-1) /* TODO: 32 -> Fixnum's max bits */ - static void -args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *const iseq, - VALUE *const passed_values, const int passed_keyword_len, const VALUE *const passed_keywords, - VALUE *const locals) +args_setup_kw_parameters(rb_execution_context_t *const ec, const rb_iseq_t *const iseq, const rb_callable_method_entry_t *cme, + VALUE *const passed_values, const int passed_keyword_len, const VALUE *const passed_keywords, + VALUE *const locals) { - const ID *acceptable_keywords = iseq->body->param.keyword->table; - const int req_key_num = iseq->body->param.keyword->required_num; - const int key_num = iseq->body->param.keyword->num; - const VALUE * const default_values = iseq->body->param.keyword->default_values; + const ID *acceptable_keywords = ISEQ_BODY(iseq)->param.keyword->table; + const int req_key_num = ISEQ_BODY(iseq)->param.keyword->required_num; + const int key_num = ISEQ_BODY(iseq)->param.keyword->num; + const VALUE * const default_values = ISEQ_BODY(iseq)->param.keyword->default_values; VALUE missing = 0; int i, di, found = 0; int unspecified_bits = 0; VALUE unspecified_bits_value = Qnil; for (i=0; i<req_key_num; i++) { - ID key = acceptable_keywords[i]; - if (args_setup_kw_parameters_lookup(key, &locals[i], passed_keywords, passed_values, passed_keyword_len)) { - found++; - } - else { - if (!missing) missing = rb_ary_tmp_new(1); - rb_ary_push(missing, ID2SYM(key)); - } + ID key = acceptable_keywords[i]; + if (args_setup_kw_parameters_lookup(key, &locals[i], passed_keywords, passed_values, passed_keyword_len)) { + found++; + } + else { + if (!missing) missing = rb_ary_hidden_new(1); + rb_ary_push(missing, ID2SYM(key)); + } + } + + if (missing) argument_kw_error(ec, iseq, cme, "missing", missing); + + for (di=0; i<key_num; i++, di++) { + if (args_setup_kw_parameters_lookup(acceptable_keywords[i], &locals[i], passed_keywords, passed_values, passed_keyword_len)) { + found++; + } + else { + if (UNDEF_P(default_values[di])) { + locals[i] = Qnil; + + if (LIKELY(i < VM_KW_SPECIFIED_BITS_MAX)) { + unspecified_bits |= 0x01 << di; + } + else { + if (NIL_P(unspecified_bits_value)) { + /* fixnum -> hash */ + int j; + unspecified_bits_value = rb_hash_new(); + + for (j=0; j<VM_KW_SPECIFIED_BITS_MAX; j++) { + if (unspecified_bits & (0x01 << j)) { + rb_hash_aset(unspecified_bits_value, INT2FIX(j), Qtrue); + } + } + } + rb_hash_aset(unspecified_bits_value, INT2FIX(di), Qtrue); + } + } + else { + locals[i] = default_values[di]; + } + } + } + + if (ISEQ_BODY(iseq)->param.flags.has_kwrest) { + const int rest_hash_index = key_num + 1; + locals[rest_hash_index] = make_rest_kw_hash(passed_keywords, passed_keyword_len, passed_values); + } + else { + if (found != passed_keyword_len) { + VALUE keys = make_unknown_kw_hash(passed_keywords, passed_keyword_len, passed_values); + argument_kw_error(ec, iseq, cme, "unknown", keys); + } + } + + if (NIL_P(unspecified_bits_value)) { + unspecified_bits_value = INT2FIX(unspecified_bits); + } + locals[key_num] = unspecified_bits_value; +} + +static void +args_setup_kw_parameters_from_kwsplat(rb_execution_context_t *const ec, const rb_iseq_t *const iseq, const rb_callable_method_entry_t *cme, + VALUE keyword_hash, VALUE *const locals, bool remove_hash_value) +{ + const ID *acceptable_keywords = ISEQ_BODY(iseq)->param.keyword->table; + const int req_key_num = ISEQ_BODY(iseq)->param.keyword->required_num; + const int key_num = ISEQ_BODY(iseq)->param.keyword->num; + const VALUE * const default_values = ISEQ_BODY(iseq)->param.keyword->default_values; + VALUE missing = 0; + int i, di; + int unspecified_bits = 0; + size_t keyword_size = RHASH_SIZE(keyword_hash); + VALUE unspecified_bits_value = Qnil; + + for (i=0; i<req_key_num; i++) { + VALUE key = ID2SYM(acceptable_keywords[i]); + VALUE value; + if (remove_hash_value) { + value = rb_hash_delete_entry(keyword_hash, key); + } + else { + value = rb_hash_lookup2(keyword_hash, key, Qundef); + } + + if (!UNDEF_P(value)) { + keyword_size--; + locals[i] = value; + } + else { + if (!missing) missing = rb_ary_hidden_new(1); + rb_ary_push(missing, key); + } } - if (missing) argument_kw_error(ec, iseq, "missing", missing); + if (missing) argument_kw_error(ec, iseq, cme, "missing", missing); for (di=0; i<key_num; i++, di++) { - if (args_setup_kw_parameters_lookup(acceptable_keywords[i], &locals[i], passed_keywords, passed_values, passed_keyword_len)) { - found++; - } - else { - if (default_values[di] == Qundef) { - locals[i] = Qnil; - - if (LIKELY(i < KW_SPECIFIED_BITS_MAX)) { - unspecified_bits |= 0x01 << di; - } - else { - if (NIL_P(unspecified_bits_value)) { - /* fixnum -> hash */ - int j; - unspecified_bits_value = rb_hash_new(); - - for (j=0; j<KW_SPECIFIED_BITS_MAX; j++) { - if (unspecified_bits & (0x01 << j)) { - rb_hash_aset(unspecified_bits_value, INT2FIX(j), Qtrue); - } - } - } - rb_hash_aset(unspecified_bits_value, INT2FIX(di), Qtrue); - } - } - else { - locals[i] = default_values[di]; - } - } - } - - if (iseq->body->param.flags.has_kwrest) { - const int rest_hash_index = key_num + 1; - locals[rest_hash_index] = make_rest_kw_hash(passed_keywords, passed_keyword_len, passed_values); + VALUE key = ID2SYM(acceptable_keywords[i]); + VALUE value; + if (remove_hash_value) { + value = rb_hash_delete_entry(keyword_hash, key); + } + else { + value = rb_hash_lookup2(keyword_hash, key, Qundef); + } + + if (!UNDEF_P(value)) { + keyword_size--; + locals[i] = value; + } + else { + if (UNDEF_P(default_values[di])) { + locals[i] = Qnil; + + if (LIKELY(i < VM_KW_SPECIFIED_BITS_MAX)) { + unspecified_bits |= 0x01 << di; + } + else { + if (NIL_P(unspecified_bits_value)) { + /* fixnum -> hash */ + int j; + unspecified_bits_value = rb_hash_new(); + + for (j=0; j<VM_KW_SPECIFIED_BITS_MAX; j++) { + if (unspecified_bits & (0x01 << j)) { + rb_hash_aset(unspecified_bits_value, INT2FIX(j), Qtrue); + } + } + } + rb_hash_aset(unspecified_bits_value, INT2FIX(di), Qtrue); + } + } + else { + locals[i] = default_values[di]; + } + } + } + + if (ISEQ_BODY(iseq)->param.flags.has_kwrest) { + const int rest_hash_index = key_num + 1; + locals[rest_hash_index] = keyword_hash; } else { - if (found != passed_keyword_len) { - VALUE keys = make_unknown_kw_hash(passed_keywords, passed_keyword_len, passed_values); - argument_kw_error(ec, iseq, "unknown", keys); - } + if (!remove_hash_value) { + if (keyword_size != 0) { + /* Recurse with duplicated keyword hash in remove mode. + * This is simpler than writing code to check which entries in the hash do not match. + * This will raise an exception, so the additional performance impact shouldn't be material. + */ + args_setup_kw_parameters_from_kwsplat(ec, iseq, cme, rb_hash_dup(keyword_hash), locals, true); + } + } + else if (!RHASH_EMPTY_P(keyword_hash)) { + argument_kw_error(ec, iseq, cme, "unknown", rb_hash_keys(keyword_hash)); + } } if (NIL_P(unspecified_bits_value)) { - unspecified_bits_value = INT2FIX(unspecified_bits); + unspecified_bits_value = INT2FIX(unspecified_bits); } locals[key_num] = unspecified_bits_value; } static inline void -args_setup_kw_rest_parameter(VALUE keyword_hash, VALUE *locals) +args_setup_kw_rest_parameter(VALUE keyword_hash, VALUE *locals, int kw_flag, bool anon_kwrest) { - locals[0] = NIL_P(keyword_hash) ? rb_hash_new() : rb_hash_dup(keyword_hash); + if (NIL_P(keyword_hash)) { + if (!anon_kwrest) { + keyword_hash = rb_hash_new(); + } + } + else if (!(kw_flag & VM_CALL_KW_SPLAT_MUT)) { + keyword_hash = rb_hash_dup(keyword_hash); + } + locals[0] = keyword_hash; } static inline void @@ -493,37 +512,94 @@ args_setup_block_parameter(const rb_execution_context_t *ec, struct rb_calling_i *locals = rb_vm_bh_to_procval(ec, block_handler); } -struct fill_values_arg { - VALUE *keys; - VALUE *vals; - int argc; -}; +static inline int +ignore_keyword_hash_p(VALUE keyword_hash, const rb_iseq_t * const iseq, unsigned int * kw_flag, VALUE * converted_keyword_hash) +{ + if (keyword_hash == Qnil) { + goto ignore; + } + else if (!RB_TYPE_P(keyword_hash, T_HASH)) { + keyword_hash = rb_to_hash_type(keyword_hash); + } + else if (UNLIKELY(ISEQ_BODY(iseq)->param.flags.anon_kwrest)) { + if (!ISEQ_BODY(iseq)->param.flags.has_kw) { + *kw_flag |= VM_CALL_KW_SPLAT_MUT; + } + } -static int -fill_keys_values(st_data_t key, st_data_t val, st_data_t ptr) + if (RHASH_EMPTY_P(keyword_hash) && !ISEQ_BODY(iseq)->param.flags.has_kwrest) { + goto ignore; + } + + if (!(*kw_flag & VM_CALL_KW_SPLAT_MUT) && + (ISEQ_BODY(iseq)->param.flags.has_kwrest || + ISEQ_BODY(iseq)->param.flags.ruby2_keywords)) { + *kw_flag |= VM_CALL_KW_SPLAT_MUT; + keyword_hash = rb_hash_dup(keyword_hash); + } + *converted_keyword_hash = keyword_hash; + + if (!(ISEQ_BODY(iseq)->param.flags.has_kw) && + !(ISEQ_BODY(iseq)->param.flags.has_kwrest) && + RHASH_EMPTY_P(keyword_hash)) { + ignore: + *kw_flag &= ~(VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT); + return 1; + } + else { + return 0; + } +} + +static VALUE +check_kwrestarg(VALUE keyword_hash, unsigned int *kw_flag) { - struct fill_values_arg *arg = (struct fill_values_arg *)ptr; - int i = arg->argc++; - arg->keys[i] = (VALUE)key; - arg->vals[i] = (VALUE)val; - return ST_CONTINUE; + if (!(*kw_flag & VM_CALL_KW_SPLAT_MUT)) { + *kw_flag |= VM_CALL_KW_SPLAT_MUT; + return rb_hash_dup(keyword_hash); + } + else { + return keyword_hash; + } +} + +static void +flatten_rest_args(rb_execution_context_t * const ec, struct args_info *args, VALUE * const locals, unsigned int *ci_flag) +{ + const VALUE *argv = RARRAY_CONST_PTR(args->rest); + int j, i=args->argc, rest_len = RARRAY_LENINT(args->rest)-1; + args->argc += rest_len; + if (rest_len) { + CHECK_VM_STACK_OVERFLOW(ec->cfp, rest_len+1); + for (j=0; rest_len > 0; rest_len--, i++, j++) { + locals[i] = argv[j]; + } + } + args->rest = Qfalse; + *ci_flag &= ~VM_CALL_ARGS_SPLAT; } static int setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * const iseq, - struct rb_calling_info *const calling, - const struct rb_call_info *ci, - VALUE * const locals, const enum arg_setup_type arg_setup_type) + struct rb_calling_info *const calling, + const struct rb_callinfo *ci, + VALUE * const locals, const enum arg_setup_type arg_setup_type) { - const int min_argc = iseq->body->param.lead_num + iseq->body->param.post_num; - const int max_argc = (iseq->body->param.flags.has_rest == FALSE) ? min_argc + iseq->body->param.opt_num : UNLIMITED_ARGUMENTS; - int opt_pc = 0; + const int min_argc = ISEQ_BODY(iseq)->param.lead_num + ISEQ_BODY(iseq)->param.post_num; + const int max_argc = (ISEQ_BODY(iseq)->param.flags.has_rest == FALSE) ? min_argc + ISEQ_BODY(iseq)->param.opt_num : UNLIMITED_ARGUMENTS; int given_argc; - int kw_splat = FALSE; + unsigned int ci_flag = vm_ci_flag(ci); + unsigned int kw_flag = ci_flag & (VM_CALL_KWARG | VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT); + int opt_pc = 0, allow_autosplat = !kw_flag; struct args_info args_body, *args; VALUE keyword_hash = Qnil; VALUE * const orig_sp = ec->cfp->sp; unsigned int i; + VALUE flag_keyword_hash = 0; + VALUE splat_flagged_keyword_hash = 0; + VALUE converted_keyword_hash = 0; + VALUE rest_last = 0; + const rb_callable_method_entry_t *cme = calling->cc ? vm_cc_cme(calling->cc) : NULL; vm_check_canary(ec, orig_sp); /* @@ -531,17 +607,17 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co * * [pushed values] [uninitialized values] * <- ci->argc --> - * <- iseq->body->param.size------------> + * <- ISEQ_BODY(iseq)->param.size------------> * ^ locals ^ sp * * => * [pushed values] [initialized values ] * <- ci->argc --> - * <- iseq->body->param.size------------> + * <- ISEQ_BODY(iseq)->param.size------------> * ^ locals ^ sp */ - for (i=calling->argc; i<iseq->body->param.size; i++) { - locals[i] = Qnil; + for (i=calling->argc; i<ISEQ_BODY(iseq)->param.size; i++) { + locals[i] = Qnil; } ec->cfp->sp = &locals[i]; @@ -549,170 +625,355 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co args = &args_body; given_argc = args->argc = calling->argc; args->argv = locals; - args->rest_dupped = FALSE; - - if (ci->flag & VM_CALL_KWARG) { - args->kw_arg = ((struct rb_call_info_with_kwarg *)ci)->kw_arg; - - if (iseq->body->param.flags.has_kw) { - int kw_len = args->kw_arg->keyword_len; - /* copy kw_argv */ - args->kw_argv = ALLOCA_N(VALUE, kw_len); - args->argc -= kw_len; - given_argc -= kw_len; - MEMCPY(args->kw_argv, locals + args->argc, VALUE, kw_len); - } - else { - args->kw_argv = NULL; - given_argc = args_kw_argv_to_hash(args); - } + args->rest_dupped = ci_flag & VM_CALL_ARGS_SPLAT_MUT; + + if (UNLIKELY(ISEQ_BODY(iseq)->param.flags.anon_rest)) { + if ((ci_flag & VM_CALL_ARGS_SPLAT) && + given_argc == ISEQ_BODY(iseq)->param.lead_num + (kw_flag ? 2 : 1) && + !ISEQ_BODY(iseq)->param.flags.has_opt && + !ISEQ_BODY(iseq)->param.flags.has_post && + !ISEQ_BODY(iseq)->param.flags.ruby2_keywords) { + if (kw_flag) { + if (ISEQ_BODY(iseq)->param.flags.has_kw || + ISEQ_BODY(iseq)->param.flags.has_kwrest) { + args->rest_dupped = true; + } + else if (kw_flag & VM_CALL_KW_SPLAT) { + VALUE kw_hash = locals[args->argc - 1]; + if (kw_hash == Qnil || + (RB_TYPE_P(kw_hash, T_HASH) && RHASH_EMPTY_P(kw_hash))) { + args->rest_dupped = true; + } + } + + } + else if (!ISEQ_BODY(iseq)->param.flags.has_kw && + !ISEQ_BODY(iseq)->param.flags.has_kwrest && + !ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg) { + args->rest_dupped = true; + } + } + } + + if (kw_flag & VM_CALL_KWARG) { + args->kw_arg = vm_ci_kwarg(ci); + + if (ISEQ_BODY(iseq)->param.flags.has_kw) { + int kw_len = args->kw_arg->keyword_len; + /* copy kw_argv */ + args->kw_argv = ALLOCA_N(VALUE, kw_len); + args->argc -= kw_len; + given_argc -= kw_len; + MEMCPY(args->kw_argv, locals + args->argc, VALUE, kw_len); + } + else { + args->kw_argv = NULL; + given_argc = args_kw_argv_to_hash(args); + kw_flag |= VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT; + } } else { - args->kw_arg = NULL; - args->kw_argv = NULL; + args->kw_arg = NULL; + args->kw_argv = NULL; } - if (ci->flag & VM_CALL_ARGS_SPLAT) { - args->rest = locals[--args->argc]; - args->rest_index = 0; - given_argc += RARRAY_LENINT(args->rest) - 1; + if ((ci_flag & VM_CALL_ARGS_SPLAT) && (ci_flag & VM_CALL_KW_SPLAT)) { + // f(*a, **kw) + args->rest_index = 0; + keyword_hash = locals[--args->argc]; + args->rest = locals[--args->argc]; + + if (ignore_keyword_hash_p(keyword_hash, iseq, &kw_flag, &converted_keyword_hash)) { + keyword_hash = Qnil; + } + else if (UNLIKELY(ISEQ_BODY(iseq)->param.flags.ruby2_keywords)) { + converted_keyword_hash = check_kwrestarg(converted_keyword_hash, &kw_flag); + flag_keyword_hash = converted_keyword_hash; + arg_rest_dup(args); + rb_ary_push(args->rest, converted_keyword_hash); + keyword_hash = Qnil; + } + else if (!ISEQ_BODY(iseq)->param.flags.has_kwrest && !ISEQ_BODY(iseq)->param.flags.has_kw) { + converted_keyword_hash = check_kwrestarg(converted_keyword_hash, &kw_flag); + if (ISEQ_BODY(iseq)->param.flags.has_rest) { + arg_rest_dup(args); + rb_ary_push(args->rest, converted_keyword_hash); + keyword_hash = Qnil; + } + else { + // Avoid duping rest when not necessary + // Copy rest elements and converted keyword hash directly to VM stack + const VALUE *argv = RARRAY_CONST_PTR(args->rest); + int j, i=args->argc, rest_len = RARRAY_LENINT(args->rest); + if (rest_len) { + CHECK_VM_STACK_OVERFLOW(ec->cfp, rest_len+1); + given_argc += rest_len; + args->argc += rest_len; + for (j=0; rest_len > 0; rest_len--, i++, j++) { + locals[i] = argv[j]; + } + } + locals[i] = converted_keyword_hash; + given_argc--; + args->argc++; + args->rest = Qfalse; + ci_flag &= ~(VM_CALL_ARGS_SPLAT|VM_CALL_KW_SPLAT); + keyword_hash = Qnil; + goto arg_splat_and_kw_splat_flattened; + } + } + else { + keyword_hash = converted_keyword_hash; + } + + int len = RARRAY_LENINT(args->rest); + given_argc += len - 2; + } + else if (ci_flag & VM_CALL_ARGS_SPLAT) { + // f(*a) + args->rest_index = 0; + args->rest = locals[--args->argc]; + int len = RARRAY_LENINT(args->rest); + given_argc += len - 1; + + if (!kw_flag && len > 0) { + rest_last = RARRAY_AREF(args->rest, len - 1); + if (RB_TYPE_P(rest_last, T_HASH) && FL_TEST_RAW(rest_last, RHASH_PASS_AS_KEYWORDS)) { + // def f(**kw); a = [..., kw]; g(*a) + splat_flagged_keyword_hash = rest_last; + if (!(RHASH_EMPTY_P(rest_last) || ISEQ_BODY(iseq)->param.flags.has_kw) || (ISEQ_BODY(iseq)->param.flags.has_kwrest)) { + rest_last = rb_hash_dup(rest_last); + } + kw_flag |= VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT; + + // Unset rest_dupped set by anon_rest as we may need to modify splat in this case + args->rest_dupped = false; + + if (ignore_keyword_hash_p(rest_last, iseq, &kw_flag, &converted_keyword_hash)) { + if (ISEQ_BODY(iseq)->param.flags.has_rest) { + // Only duplicate/modify splat array if it will be used + arg_rest_dup(args); + rb_ary_pop(args->rest); + } + else if (arg_setup_type == arg_setup_block && !ISEQ_BODY(iseq)->param.flags.has_kwrest) { + // Avoid hash allocation for empty hashes + // Copy rest elements except empty keyword hash directly to VM stack + flatten_rest_args(ec, args, locals, &ci_flag); + keyword_hash = Qnil; + kw_flag = 0; + } + given_argc--; + } + else if (!ISEQ_BODY(iseq)->param.flags.has_rest) { + // Avoid duping rest when not necessary + // Copy rest elements and converted keyword hash directly to VM stack + flatten_rest_args(ec, args, locals, &ci_flag); + + if (ISEQ_BODY(iseq)->param.flags.has_kw || ISEQ_BODY(iseq)->param.flags.has_kwrest) { + given_argc--; + keyword_hash = converted_keyword_hash; + } + else { + locals[args->argc] = converted_keyword_hash; + args->argc += 1; + keyword_hash = Qnil; + kw_flag = 0; + } + } + else { + if (rest_last != converted_keyword_hash) { + rest_last = converted_keyword_hash; + arg_rest_dup(args); + RARRAY_ASET(args->rest, len - 1, rest_last); + } + + if (ISEQ_BODY(iseq)->param.flags.ruby2_keywords && rest_last) { + flag_keyword_hash = rest_last; + } + else if (ISEQ_BODY(iseq)->param.flags.has_kw || ISEQ_BODY(iseq)->param.flags.has_kwrest) { + arg_rest_dup(args); + rb_ary_pop(args->rest); + given_argc--; + keyword_hash = rest_last; + } + } + } + } } else { - args->rest = Qfalse; + args->rest = Qfalse; + + if (args->argc > 0 && (kw_flag & VM_CALL_KW_SPLAT)) { + // f(**kw) + VALUE last_arg = args->argv[args->argc-1]; + if (ignore_keyword_hash_p(last_arg, iseq, &kw_flag, &converted_keyword_hash)) { + args->argc--; + given_argc--; + } + else { + if (!(kw_flag & VM_CALL_KW_SPLAT_MUT) && !ISEQ_BODY(iseq)->param.flags.has_kw) { + converted_keyword_hash = rb_hash_dup(converted_keyword_hash); + kw_flag |= VM_CALL_KW_SPLAT_MUT; + } + + if (last_arg != converted_keyword_hash) { + last_arg = converted_keyword_hash; + args->argv[args->argc-1] = last_arg; + } + + if (ISEQ_BODY(iseq)->param.flags.ruby2_keywords) { + flag_keyword_hash = last_arg; + } + else if (ISEQ_BODY(iseq)->param.flags.has_kw || ISEQ_BODY(iseq)->param.flags.has_kwrest) { + args->argc--; + given_argc--; + keyword_hash = last_arg; + } + } + } + } + + if (flag_keyword_hash) { + FL_SET_RAW(flag_keyword_hash, RHASH_PASS_AS_KEYWORDS); + } + + arg_splat_and_kw_splat_flattened: + if (kw_flag && ISEQ_BODY(iseq)->param.flags.accepts_no_kwarg) { + rb_raise(rb_eArgError, "no keywords accepted"); } switch (arg_setup_type) { case arg_setup_method: - break; /* do nothing special */ + break; /* do nothing special */ case arg_setup_block: - if (given_argc == 1 && - (min_argc > 0 || iseq->body->param.opt_num > 1 || - iseq->body->param.flags.has_kw || iseq->body->param.flags.has_kwrest) && - !iseq->body->param.flags.ambiguous_param0 && - args_check_block_arg0(args)) { - given_argc = RARRAY_LENINT(args->rest); - } - break; + if (given_argc == 1 && + allow_autosplat && + !splat_flagged_keyword_hash && + (min_argc > 0 || ISEQ_BODY(iseq)->param.opt_num > 1) && + !ISEQ_BODY(iseq)->param.flags.ambiguous_param0 && + !((ISEQ_BODY(iseq)->param.flags.has_kw || + ISEQ_BODY(iseq)->param.flags.has_kwrest) + && max_argc == 1) && + args_check_block_arg0(args)) { + given_argc = RARRAY_LENINT(args->rest); + } + break; } /* argc check */ if (given_argc < min_argc) { - if (given_argc == min_argc - 1 && args->kw_argv) { - args_stored_kw_argv_to_hash(args); - given_argc = args_argc(args); - } - else { - if (arg_setup_type == arg_setup_block) { - CHECK_VM_STACK_OVERFLOW(ec->cfp, min_argc); - given_argc = min_argc; - args_extend(args, min_argc); - } - else { - argument_arity_error(ec, iseq, given_argc, min_argc, max_argc); - } - } - } - - if (ci->flag & VM_CALL_KW_SPLAT) { - kw_splat = !iseq->body->param.flags.has_rest; - } - if (given_argc > min_argc && - (iseq->body->param.flags.has_kw || iseq->body->param.flags.has_kwrest || - (kw_splat && given_argc > max_argc)) && - args->kw_argv == NULL) { - if (args_pop_keyword_hash(args, &keyword_hash)) { - given_argc--; - } + if (arg_setup_type == arg_setup_block) { + CHECK_VM_STACK_OVERFLOW(ec->cfp, min_argc); + given_argc = min_argc; + args_extend(args, min_argc); + } + else { + argument_arity_error(ec, iseq, cme, given_argc, min_argc, max_argc); + } } if (given_argc > max_argc && max_argc != UNLIMITED_ARGUMENTS) { - if (arg_setup_type == arg_setup_block) { - /* truncate */ - args_reduce(args, given_argc - max_argc); - given_argc = max_argc; - } - else { - argument_arity_error(ec, iseq, given_argc, min_argc, max_argc); - } + if (arg_setup_type == arg_setup_block) { + /* truncate */ + args_reduce(args, given_argc - max_argc); + given_argc = max_argc; + } + else { + argument_arity_error(ec, iseq, cme, given_argc, min_argc, max_argc); + } } - if (iseq->body->param.flags.has_lead) { - args_setup_lead_parameters(args, iseq->body->param.lead_num, locals + 0); + if (ISEQ_BODY(iseq)->param.flags.has_lead) { + args_setup_lead_parameters(args, ISEQ_BODY(iseq)->param.lead_num, locals + 0); } - if (iseq->body->param.flags.has_rest || iseq->body->param.flags.has_post){ + if (ISEQ_BODY(iseq)->param.flags.has_rest || ISEQ_BODY(iseq)->param.flags.has_post){ args_copy(args); } - if (iseq->body->param.flags.has_post) { - args_setup_post_parameters(args, iseq->body->param.post_num, locals + iseq->body->param.post_start); + if (ISEQ_BODY(iseq)->param.flags.has_post) { + args_setup_post_parameters(args, ISEQ_BODY(iseq)->param.post_num, locals + ISEQ_BODY(iseq)->param.post_start); } - if (iseq->body->param.flags.has_opt) { - int opt = args_setup_opt_parameters(args, iseq->body->param.opt_num, locals + iseq->body->param.lead_num); - opt_pc = (int)iseq->body->param.opt_table[opt]; + if (ISEQ_BODY(iseq)->param.flags.has_opt) { + int opt = args_setup_opt_parameters(args, ISEQ_BODY(iseq)->param.opt_num, locals + ISEQ_BODY(iseq)->param.lead_num); + opt_pc = (int)ISEQ_BODY(iseq)->param.opt_table[opt]; } - if (iseq->body->param.flags.has_rest) { - args_setup_rest_parameter(args, locals + iseq->body->param.rest_start); + if (ISEQ_BODY(iseq)->param.flags.has_rest) { + if (UNLIKELY(ISEQ_BODY(iseq)->param.flags.anon_rest && args->argc == 0 && !args->rest && !ISEQ_BODY(iseq)->param.flags.has_post)) { + *(locals + ISEQ_BODY(iseq)->param.rest_start) = args->rest = rb_cArray_empty_frozen; + args->rest_index = 0; + } + else { + args_setup_rest_parameter(args, locals + ISEQ_BODY(iseq)->param.rest_start); + VALUE ary = *(locals + ISEQ_BODY(iseq)->param.rest_start); + VALUE index = RARRAY_LEN(ary) - 1; + if (splat_flagged_keyword_hash && + !ISEQ_BODY(iseq)->param.flags.ruby2_keywords && + !ISEQ_BODY(iseq)->param.flags.has_kw && + !ISEQ_BODY(iseq)->param.flags.has_kwrest && + RARRAY_AREF(ary, index) == splat_flagged_keyword_hash) { + ((struct RHash *)rest_last)->basic.flags &= ~RHASH_PASS_AS_KEYWORDS; + RARRAY_ASET(ary, index, rest_last); + } + } } - if (iseq->body->param.flags.has_kw) { - VALUE * const klocals = locals + iseq->body->param.keyword->bits_start - iseq->body->param.keyword->num; + if (ISEQ_BODY(iseq)->param.flags.has_kw) { + VALUE * const klocals = locals + ISEQ_BODY(iseq)->param.keyword->bits_start - ISEQ_BODY(iseq)->param.keyword->num; - if (args->kw_argv != NULL) { - const struct rb_call_info_kw_arg *kw_arg = args->kw_arg; - args_setup_kw_parameters(ec, iseq, args->kw_argv, kw_arg->keyword_len, kw_arg->keywords, klocals); - } - else if (!NIL_P(keyword_hash)) { - int kw_len = rb_long2int(RHASH_SIZE(keyword_hash)); - struct fill_values_arg arg; - /* copy kw_argv */ - arg.keys = args->kw_argv = ALLOCA_N(VALUE, kw_len * 2); - arg.vals = arg.keys + kw_len; - arg.argc = 0; - rb_hash_foreach(keyword_hash, fill_keys_values, (VALUE)&arg); - VM_ASSERT(arg.argc == kw_len); - args_setup_kw_parameters(ec, iseq, arg.vals, kw_len, arg.keys, klocals); - } - else { - VM_ASSERT(args_argc(args) == 0); - args_setup_kw_parameters(ec, iseq, NULL, 0, NULL, klocals); - } - } - else if (iseq->body->param.flags.has_kwrest) { - args_setup_kw_rest_parameter(keyword_hash, locals + iseq->body->param.keyword->rest_start); + if (args->kw_argv != NULL) { + const struct rb_callinfo_kwarg *kw_arg = args->kw_arg; + args_setup_kw_parameters(ec, iseq, cme, args->kw_argv, kw_arg->keyword_len, kw_arg->keywords, klocals); + } + else if (!NIL_P(keyword_hash)) { + bool remove_hash_value = false; + if (ISEQ_BODY(iseq)->param.flags.has_kwrest) { + keyword_hash = check_kwrestarg(keyword_hash, &kw_flag); + remove_hash_value = true; + } + args_setup_kw_parameters_from_kwsplat(ec, iseq, cme, keyword_hash, klocals, remove_hash_value); + } + else { +#if VM_CHECK_MODE > 0 + if (args_argc(args) != 0) { + VM_ASSERT(ci_flag & VM_CALL_ARGS_SPLAT); + VM_ASSERT(!(ci_flag & (VM_CALL_KWARG | VM_CALL_KW_SPLAT | VM_CALL_KW_SPLAT_MUT))); + VM_ASSERT(!kw_flag); + VM_ASSERT(!ISEQ_BODY(iseq)->param.flags.has_rest); + VM_ASSERT(RARRAY_LENINT(args->rest) > 0); + VM_ASSERT(RB_TYPE_P(rest_last, T_HASH)); + VM_ASSERT(FL_TEST_RAW(rest_last, RHASH_PASS_AS_KEYWORDS)); + VM_ASSERT(args_argc(args) == 1); + } +#endif + args_setup_kw_parameters(ec, iseq, cme, NULL, 0, NULL, klocals); + } } - else if (!NIL_P(keyword_hash) && RHASH_SIZE(keyword_hash) > 0) { - argument_kw_error(ec, iseq, "unknown", rb_hash_keys(keyword_hash)); + else if (ISEQ_BODY(iseq)->param.flags.has_kwrest) { + args_setup_kw_rest_parameter(keyword_hash, locals + ISEQ_BODY(iseq)->param.keyword->rest_start, + kw_flag, ISEQ_BODY(iseq)->param.flags.anon_kwrest); } - else if (kw_splat && NIL_P(keyword_hash)) { - if (RTEST(ruby_verbose)) { - VALUE path = rb_iseq_path(iseq); - VALUE line = rb_iseq_first_lineno(iseq); - VALUE label = rb_iseq_label(iseq); - rb_compile_warning(NIL_P(path) ? NULL : RSTRING_PTR(path), FIX2INT(line), - "in `%s': the last argument was passed as a single Hash", - NIL_P(label) ? NULL : RSTRING_PTR(label)); - rb_warning("although a splat keyword arguments here"); - } + else if (!NIL_P(keyword_hash) && RHASH_SIZE(keyword_hash) > 0 && arg_setup_type == arg_setup_method) { + argument_kw_error(ec, iseq, cme, "unknown", rb_hash_keys(keyword_hash)); } - if (iseq->body->param.flags.has_block) { - if (iseq->body->local_iseq == iseq) { - /* Do nothing */ - } - else { - args_setup_block_parameter(ec, calling, locals + iseq->body->param.block_start); - } + if (ISEQ_BODY(iseq)->param.flags.has_block) { + if (ISEQ_BODY(iseq)->local_iseq == iseq) { + /* Do nothing */ + } + else { + args_setup_block_parameter(ec, calling, locals + ISEQ_BODY(iseq)->param.block_start); + } } #if 0 { - int i; - for (i=0; i<iseq->body->param.size; i++) { - fprintf(stderr, "local[%d] = %p\n", i, (void *)locals[i]); - } + int i; + for (i=0; i<ISEQ_BODY(iseq)->param.size; i++) { + ruby_debug_printf("local[%d] = %p\n", i, (void *)locals[i]); + } } #endif @@ -720,24 +981,21 @@ setup_parameters_complex(rb_execution_context_t * const ec, const rb_iseq_t * co return opt_pc; } -void rb_backtrace_use_iseq_first_lineno_for_last_location(VALUE self); /* vm_backtrace.c */ - static void -raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const VALUE exc) +raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const VALUE exc) { VALUE at; if (iseq) { - vm_push_frame(ec, iseq, VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL, Qnil /* self */, - VM_BLOCK_HANDLER_NONE /* specval*/, Qfalse /* me or cref */, - iseq->body->iseq_encoded, - ec->cfp->sp, 0, 0 /* stack_max */); - at = rb_ec_backtrace_object(ec); - rb_backtrace_use_iseq_first_lineno_for_last_location(at); - rb_vm_pop_frame(ec); + vm_push_frame(ec, iseq, VM_FRAME_MAGIC_DUMMY | VM_ENV_FLAG_LOCAL, Qnil /* self */, + VM_BLOCK_HANDLER_NONE /* specval*/, (VALUE) cme /* me or cref */, + ISEQ_BODY(iseq)->iseq_encoded, + ec->cfp->sp, 0, 0 /* stack_max */); + at = rb_ec_backtrace_object(ec); + rb_vm_pop_frame(ec); } else { - at = rb_ec_backtrace_object(ec); + at = rb_ec_backtrace_object(ec); } rb_ivar_set(exc, idBt_locations, at); @@ -746,103 +1004,69 @@ raise_argument_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const VA } static void -argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const int miss_argc, const int min_argc, const int max_argc) +argument_arity_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const int miss_argc, const int min_argc, const int max_argc) { VALUE exc = rb_arity_error_new(miss_argc, min_argc, max_argc); - if (iseq->body->param.flags.has_kw) { - const struct rb_iseq_param_keyword *const kw = iseq->body->param.keyword; - const ID *keywords = kw->table; - int req_key_num = kw->required_num; - if (req_key_num > 0) { - static const char required[] = "; required keywords"; - VALUE mesg = rb_attr_get(exc, idMesg); - rb_str_resize(mesg, RSTRING_LEN(mesg)-1); - rb_str_cat(mesg, required, sizeof(required) - 1 - (req_key_num == 1)); - rb_str_cat_cstr(mesg, ":"); - do { - rb_str_cat_cstr(mesg, " "); - rb_str_append(mesg, rb_id2str(*keywords++)); - rb_str_cat_cstr(mesg, ","); - } while (--req_key_num); - RSTRING_PTR(mesg)[RSTRING_LEN(mesg)-1] = ')'; - } - } - raise_argument_error(ec, iseq, exc); -} - -static void -argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const char *error, const VALUE keys) -{ - raise_argument_error(ec, iseq, rb_keyword_error_new(error, keys)); -} - -static inline void -vm_caller_setup_arg_splat(rb_control_frame_t *cfp, struct rb_calling_info *calling) -{ - int argc = calling->argc; - VALUE *argv = cfp->sp - argc; - VALUE ary = argv[argc-1]; - - vm_check_canary(GET_EC(), cfp->sp); - cfp->sp--; - - if (!NIL_P(ary)) { - const VALUE *ptr = RARRAY_CONST_PTR_TRANSIENT(ary); - long len = RARRAY_LEN(ary), i; - - CHECK_VM_STACK_OVERFLOW(cfp, len); - - for (i = 0; i < len; i++) { - *cfp->sp++ = ptr[i]; + if (ISEQ_BODY(iseq)->param.flags.has_kw) { + const struct rb_iseq_param_keyword *const kw = ISEQ_BODY(iseq)->param.keyword; + const ID *keywords = kw->table; + int req_key_num = kw->required_num; + if (req_key_num > 0) { + static const char required[] = "; required keywords"; + VALUE mesg = rb_attr_get(exc, idMesg); + rb_str_resize(mesg, RSTRING_LEN(mesg)-1); + rb_str_cat(mesg, required, sizeof(required) - 1 - (req_key_num == 1)); + rb_str_cat_cstr(mesg, ":"); + do { + rb_str_cat_cstr(mesg, " "); + rb_str_append(mesg, rb_id2str(*keywords++)); + rb_str_cat_cstr(mesg, ","); + } while (--req_key_num); + RSTRING_PTR(mesg)[RSTRING_LEN(mesg)-1] = ')'; } - calling->argc += i - 1; } + raise_argument_error(ec, iseq, cme, exc); } -static inline void -vm_caller_setup_arg_kw(rb_control_frame_t *cfp, struct rb_calling_info *calling, const struct rb_call_info *ci) +static void +argument_kw_error(rb_execution_context_t *ec, const rb_iseq_t *iseq, const rb_callable_method_entry_t *cme, const char *error, const VALUE keys) { - struct rb_call_info_with_kwarg *ci_kw = (struct rb_call_info_with_kwarg *)ci; - const VALUE *const passed_keywords = ci_kw->kw_arg->keywords; - const int kw_len = ci_kw->kw_arg->keyword_len; - const VALUE h = rb_hash_new_with_size(kw_len); - VALUE *sp = cfp->sp; - int i; - - for (i=0; i<kw_len; i++) { - rb_hash_aset(h, passed_keywords[i], (sp - kw_len)[i]); - } - (sp-kw_len)[0] = h; - - cfp->sp -= kw_len - 1; - calling->argc -= kw_len - 1; + raise_argument_error(ec, iseq, cme, rb_keyword_error_new(error, keys)); } static VALUE vm_to_proc(VALUE proc) { if (UNLIKELY(!rb_obj_is_proc(proc))) { - VALUE b; - const rb_callable_method_entry_t *me = - rb_callable_method_entry_with_refinements(CLASS_OF(proc), idTo_proc, NULL); - - if (me) { - b = rb_vm_call0(GET_EC(), proc, idTo_proc, 0, NULL, me); - } - else { - /* NOTE: calling method_missing */ - b = rb_check_convert_type_with_id(proc, T_DATA, "Proc", idTo_proc); - } - - if (NIL_P(b) || !rb_obj_is_proc(b)) { - rb_raise(rb_eTypeError, - "wrong argument type %s (expected Proc)", - rb_obj_classname(proc)); - } - return b; + VALUE b; + const rb_callable_method_entry_t *me = + rb_callable_method_entry_with_refinements(CLASS_OF(proc), idTo_proc, NULL); + + if (me) { + b = rb_vm_call0(GET_EC(), proc, idTo_proc, 0, NULL, me, RB_NO_KEYWORDS); + } + else { + /* NOTE: calling method_missing */ + b = rb_check_convert_type_with_id(proc, T_DATA, "Proc", idTo_proc); + } + + if (NIL_P(b) || !rb_obj_is_proc(b)) { + if (me) { + VALUE cname = rb_obj_class(proc); + rb_raise(rb_eTypeError, + "can't convert %"PRIsVALUE" to Proc (%"PRIsVALUE"#to_proc gives %"PRIsVALUE")", + cname, cname, rb_obj_class(b)); + } + else { + rb_raise(rb_eTypeError, + "no implicit conversion of %s into Proc", + rb_obj_classname(proc)); + } + } + return b; } else { - return proc; + return proc; } } @@ -851,14 +1075,15 @@ refine_sym_proc_call(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)) { VALUE obj; ID mid; - const rb_callable_method_entry_t *me; + const rb_callable_method_entry_t *me = 0; /* for hidden object case */ rb_execution_context_t *ec; const VALUE symbol = RARRAY_AREF(callback_arg, 0); const VALUE refinements = RARRAY_AREF(callback_arg, 1); + int kw_splat = RB_PASS_CALLED_KEYWORDS; VALUE klass; if (argc-- < 1) { - rb_raise(rb_eArgError, "no receiver given"); + rb_raise(rb_eArgError, "no receiver given"); } obj = *argv++; @@ -873,43 +1098,43 @@ refine_sym_proc_call(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_arg, callback_arg)) ec = GET_EC(); if (!NIL_P(blockarg)) { - vm_passed_block_handler_set(ec, blockarg); + vm_passed_block_handler_set(ec, blockarg); } if (!me) { - return method_missing(obj, mid, argc, argv, MISSING_NOENTRY); + return method_missing(ec, obj, mid, argc, argv, MISSING_NOENTRY, kw_splat); } - return rb_vm_call0(ec, obj, mid, argc, argv, me); + return rb_vm_call0(ec, obj, mid, argc, argv, me, kw_splat); } static VALUE vm_caller_setup_arg_block(const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, - const struct rb_call_info *ci, const rb_iseq_t *blockiseq, const int is_super) + const struct rb_callinfo *ci, const rb_iseq_t *blockiseq, const int is_super) { - if (ci->flag & VM_CALL_ARGS_BLOCKARG) { - VALUE block_code = *(--reg_cfp->sp); + if (vm_ci_flag(ci) & VM_CALL_ARGS_BLOCKARG) { + VALUE block_code = *(--reg_cfp->sp); - if (NIL_P(block_code)) { + if (NIL_P(block_code)) { return VM_BLOCK_HANDLER_NONE; } - else if (block_code == rb_block_param_proxy) { + else if (block_code == rb_block_param_proxy) { return VM_CF_BLOCK_HANDLER(reg_cfp); } - else if (SYMBOL_P(block_code) && rb_method_basic_definition_p(rb_cSymbol, idTo_proc)) { - const rb_cref_t *cref = vm_env_cref(reg_cfp->ep); - if (cref && !NIL_P(cref->refinements)) { - VALUE ref = cref->refinements; - VALUE func = rb_hash_lookup(ref, block_code); - if (NIL_P(func)) { - /* TODO: limit cached funcs */ - VALUE callback_arg = rb_ary_tmp_new(2); + else if (SYMBOL_P(block_code) && rb_method_basic_definition_p(rb_cSymbol, idTo_proc)) { + const rb_cref_t *cref = vm_env_cref(reg_cfp->ep); + if (cref && !NIL_P(cref->refinements)) { + VALUE ref = cref->refinements; + VALUE func = rb_hash_lookup(ref, block_code); + if (NIL_P(func)) { + /* TODO: limit cached funcs */ + VALUE callback_arg = rb_ary_hidden_new(2); rb_ary_push(callback_arg, block_code); rb_ary_push(callback_arg, ref); - OBJ_FREEZE_RAW(callback_arg); - func = rb_func_proc_new(refine_sym_proc_call, callback_arg); - rb_hash_aset(ref, block_code, func); - } - block_code = func; - } + OBJ_FREEZE(callback_arg); + func = rb_func_lambda_new(refine_sym_proc_call, callback_arg, 1, UNLIMITED_ARGUMENTS); + rb_hash_aset(ref, block_code, func); + } + block_code = func; + } return block_code; } else { @@ -917,12 +1142,12 @@ vm_caller_setup_arg_block(const rb_execution_context_t *ec, rb_control_frame_t * } } else if (blockiseq != NULL) { /* likely */ - struct rb_captured_block *captured = VM_CFP_TO_CAPTURED_BLOCK(reg_cfp); - captured->code.iseq = blockiseq; + struct rb_captured_block *captured = VM_CFP_TO_CAPTURED_BLOCK(reg_cfp); + captured->code.iseq = blockiseq; return VM_BH_FROM_ISEQ_BLOCK(captured); } else { - if (is_super) { + if (is_super) { return GET_BLOCK_HANDLER(); } else { @@ -930,3 +1155,57 @@ vm_caller_setup_arg_block(const rb_execution_context_t *ec, rb_control_frame_t * } } } + +static void vm_adjust_stack_forwarding(const struct rb_execution_context_struct *ec, struct rb_control_frame_struct *cfp, int argc, VALUE splat); + +static VALUE +vm_caller_setup_fwd_args(const rb_execution_context_t *ec, rb_control_frame_t *reg_cfp, + CALL_DATA cd, const rb_iseq_t *blockiseq, const int is_super, + struct rb_forwarding_call_data *adjusted_cd, struct rb_callinfo *adjusted_ci) +{ + CALL_INFO site_ci = cd->ci; + VALUE bh = Qundef; + + RUBY_ASSERT(ISEQ_BODY(ISEQ_BODY(GET_ISEQ())->local_iseq)->param.flags.forwardable); + CALL_INFO caller_ci = (CALL_INFO)TOPN(0); + + unsigned int site_argc = vm_ci_argc(site_ci); + unsigned int site_flag = vm_ci_flag(site_ci); + ID site_mid = vm_ci_mid(site_ci); + + unsigned int caller_argc = vm_ci_argc(caller_ci); + unsigned int caller_flag = vm_ci_flag(caller_ci); + const struct rb_callinfo_kwarg * kw = vm_ci_kwarg(caller_ci); + + VALUE splat = Qfalse; + + if (site_flag & VM_CALL_ARGS_SPLAT) { + // If we're called with args_splat, the top 1 should be an array + splat = TOPN(1); + site_argc += (RARRAY_LEN(splat) - 1); + } + + // Need to setup the block in case of e.g. `super { :block }` + if (is_super && blockiseq) { + bh = vm_caller_setup_arg_block(ec, GET_CFP(), site_ci, blockiseq, is_super); + } + else { + bh = VM_ENV_BLOCK_HANDLER(GET_LEP()); + } + + vm_adjust_stack_forwarding(ec, GET_CFP(), caller_argc, splat); + + *adjusted_ci = VM_CI_ON_STACK( + site_mid, + ((caller_flag & ~(VM_CALL_ARGS_SIMPLE | VM_CALL_FCALL)) | + (site_flag & (VM_CALL_FCALL | VM_CALL_FORWARDING))), + site_argc + caller_argc, + kw + ); + + adjusted_cd->cd.ci = adjusted_ci; + adjusted_cd->cd.cc = cd->cc; + adjusted_cd->caller_ci = caller_ci; + + return bh; +} |