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

merge revision(s) 54141,54542,54548: [Backport #12082]

Browse source 
test_optimization.rb: tailcall

	* test/ruby/test_optimization.rb (TestRubyOptimization.tailcall):
  helper method to compile methods with tailcall optimization
  enabled.
	* compile.c (iseq_optimize): disable tail call optimization in
	  rescued, rescue, and ensure blocks.
	  [ruby-core:73871] [Bug #12082]

	* compile.c (new_label_body): initialize bit fields, since
	  compile_data_alloc does not clear the memory.  [Bug #12082]


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_2_3@54715 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
nagachika 2016-04-22 15:59:34 +00:00
parent 9224427bb5
commit b8aa41003e
4 changed files with 123 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

11
ChangeLog
View file

@ -1,3 +1,14 @@
Sat Apr 23 00:51:51 2016 Nobuyoshi Nakada <nobu@ruby-lang.org>
* compile.c (new_label_body): initialize bit fields, since
compile_data_alloc does not clear the memory. [Bug #12082]
Sat Apr 23 00:51:51 2016 Nobuyoshi Nakada <nobu@ruby-lang.org>
* compile.c (iseq_optimize): disable tail call optimization in
rescued, rescue, and ensure blocks.
[ruby-core:73871] [Bug #12082]
Sat Apr 23 00:33:04 2016 NARUSE, Yui <naruse@ruby-lang.org>
* ext/nkf/nkf-utf8/nkf.c (mime_putc): fix typo.

49
compile.c
View file

@ -47,6 +47,13 @@ typedef struct iseq_link_anchor {
LINK_ELEMENT *last;
} LINK_ANCHOR;
typedef enum {
LABEL_RESCUE_NONE,
LABEL_RESCUE_BEG,
LABEL_RESCUE_END,
LABEL_RESCUE_TYPE_MAX
} LABEL_RESCUE_TYPE;
typedef struct iseq_label_data {
LINK_ELEMENT link;
int label_no;
@ -55,6 +62,7 @@ typedef struct iseq_label_data {
int set;
int sp;
int refcnt;
unsigned int rescued: 2;
} LABEL;
typedef struct iseq_insn_data {
@ -561,6 +569,9 @@ rb_iseq_compile_node(rb_iseq_t *iseq, NODE *node)
LABEL *start = ISEQ_COMPILE_DATA(iseq)->start_label = NEW_LABEL(0);
LABEL *end = ISEQ_COMPILE_DATA(iseq)->end_label = NEW_LABEL(0);
start->rescued = LABEL_RESCUE_BEG;
end->rescued = LABEL_RESCUE_END;
ADD_TRACE(ret, FIX2INT(iseq->body->location.first_lineno), RUBY_EVENT_B_CALL);
ADD_LABEL(ret, start);
COMPILE(ret, "block body", node->nd_body);
@ -989,6 +1000,8 @@ new_label_body(rb_iseq_t *iseq, long line)
labelobj->sc_state = 0;
labelobj->sp = -1;
labelobj->refcnt = 0;
labelobj->set = 0;
labelobj->rescued = LABEL_RESCUE_NONE;
return labelobj;
}
@ -2323,20 +2336,37 @@ iseq_specialized_instruction(rb_iseq_t *iseq, INSN *iobj)
return COMPILE_OK;
}
static inline int
tailcallable_p(rb_iseq_t *iseq)
{
switch (iseq->body->type) {
case ISEQ_TYPE_RESCUE:
case ISEQ_TYPE_ENSURE:
/* rescue block can't tail call because of errinfo */
return FALSE;
default:
return TRUE;
}
}
static int
iseq_optimize(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
{
LINK_ELEMENT *list;
const int do_peepholeopt = ISEQ_COMPILE_DATA(iseq)->option->peephole_optimization;
const int do_tailcallopt = ISEQ_COMPILE_DATA(iseq)->option->tailcall_optimization;
const int do_tailcallopt = tailcallable_p(iseq) &&
ISEQ_COMPILE_DATA(iseq)->option->tailcall_optimization;
const int do_si = ISEQ_COMPILE_DATA(iseq)->option->specialized_instruction;
const int do_ou = ISEQ_COMPILE_DATA(iseq)->option->operands_unification;
int rescue_level = 0;
int tailcallopt = do_tailcallopt;
list = FIRST_ELEMENT(anchor);
while (list) {
if (list->type == ISEQ_ELEMENT_INSN) {
if (do_peepholeopt) {
iseq_peephole_optimize(iseq, list, do_tailcallopt);
iseq_peephole_optimize(iseq, list, tailcallopt);
}
if (do_si) {
iseq_specialized_instruction(iseq, (INSN *)list);
@ -2345,6 +2375,17 @@ iseq_optimize(rb_iseq_t *iseq, LINK_ANCHOR *anchor)
insn_operands_unification((INSN *)list);
}
}
if (list->type == ISEQ_ELEMENT_LABEL) {
switch (((LABEL *)list)->rescued) {
case LABEL_RESCUE_BEG:
rescue_level++;
tailcallopt = FALSE;
break;
case LABEL_RESCUE_END:
if (!--rescue_level) tailcallopt = do_tailcallopt;
break;
}
}
list = list->next;
}
return COMPILE_OK;
@ -3449,6 +3490,8 @@ defined_expr(rb_iseq_t *iseq, LINK_ANCHOR *ret,
("defined guard in "),
iseq->body->location.label),
ISEQ_TYPE_DEFINED_GUARD, 0);
lstart->rescued = LABEL_RESCUE_BEG;
lend->rescued = LABEL_RESCUE_END;
APPEND_LABEL(ret, lcur, lstart);
ADD_LABEL(ret, lend);
ADD_CATCH_ENTRY(CATCH_TYPE_RESCUE, lstart, lend, rescue, lfinish[1]);
@ -4246,6 +4289,8 @@ iseq_compile_each(rb_iseq_t *iseq, LINK_ANCHOR *ret, NODE * node, int poped)
rb_str_concat(rb_str_new2("rescue in "), iseq->body->location.label),
ISEQ_TYPE_RESCUE, line);
lstart->rescued = LABEL_RESCUE_BEG;
lend->rescued = LABEL_RESCUE_END;
ADD_LABEL(ret, lstart);
COMPILE(ret, "rescue head", node->nd_head);
ADD_LABEL(ret, lend);

100
test/ruby/test_optimization.rb
View file

@ -230,47 +230,54 @@ class TestRubyOptimization < Test::Unit::TestCase
assert_equal true, MyObj.new == nil
end
def self.tailcall(klass, src, file = nil, path = nil, line = nil)
unless file
loc, = caller_locations(1, 1)
file = loc.path
line ||= loc.lineno
end
RubyVM::InstructionSequence.new("proc {|_|_.class_eval {#{src}}}",
file, (path || file), line,
tailcall_optimization: true,
trace_instruction: false)
.eval[klass]
end
def tailcall(*args)
self.class.tailcall(singleton_class, *args)
end
def test_tailcall
bug4082 = '[ruby-core:33289]'
option = {
tailcall_optimization: true,
trace_instruction: false,
}
RubyVM::InstructionSequence.new(<<-EOF, "Bug#4082", bug4082, nil, option).eval
class #{self.class}::Tailcall
def fact_helper(n, res)
if n == 1
res
else
fact_helper(n - 1, n * res)
end
end
def fact(n)
fact_helper(n, 1)
tailcall(<<-EOF)
def fact_helper(n, res)
if n == 1
res
else
fact_helper(n - 1, n * res)
end
end
def fact(n)
fact_helper(n, 1)
end
EOF
assert_equal(9131, Tailcall.new.fact(3000).to_s.size, bug4082)
assert_equal(9131, fact(3000).to_s.size, bug4082)
end
def test_tailcall_with_block
bug6901 = '[ruby-dev:46065]'
option = {
tailcall_optimization: true,
trace_instruction: false,
}
RubyVM::InstructionSequence.new(<<-EOF, "Bug#6901", bug6901, nil, option).eval
def identity(val)
val
end
tailcall(<<-EOF)
def identity(val)
val
end
def delay
-> {
identity(yield)
}
end
def delay
-> {
identity(yield)
}
end
EOF
assert_equal(123, delay { 123 }.call, bug6901)
end
@ -280,15 +287,36 @@ class TestRubyOptimization < Test::Unit::TestCase
end
def test_tailcall_inhibited_by_block
assert_separately([], <<~'end;')
def just_yield
yield
tailcall(<<-EOF)
def yield_result
just_yield {:ok}
end
EOF
assert_equal(:ok, yield_result)
end
def do_raise
raise "should be rescued"
end
def errinfo
$!
end
def test_tailcall_inhibited_by_rescue
bug12082 = '[ruby-core:73871] [Bug #12082]'
tailcall(<<-'end;')
def to_be_rescued
return do_raise
1 + 2
rescue
errinfo
end
iseq = RubyVM::InstructionSequence
result = iseq.compile("just_yield {:ok}", __FILE__, __FILE__, __LINE__,
tailcall_optimization: true).eval
assert_equal(:ok, result)
end;
result = to_be_rescued
assert_instance_of(RuntimeError, result, bug12082)
assert_equal("should be rescued", result.message, bug12082)
end
class Bug10557

2
version.h
View file

@ -1,6 +1,6 @@
#define RUBY_VERSION "2.3.0"
#define RUBY_RELEASE_DATE "2016-04-23"
#define RUBY_PATCHLEVEL 104
#define RUBY_PATCHLEVEL 105
#define RUBY_RELEASE_YEAR 2016
#define RUBY_RELEASE_MONTH 4