Author: Jeremy Thurgood <[email protected]>
Branch: unrecursive-opt
Changeset: r79977:c1e114708b34
Date: 2015-10-04 16:39 +0200
http://bitbucket.org/pypy/pypy/changeset/c1e114708b34/
Log: Move rewrite callbacks to postprocess pass, one test fails.
diff --git a/rpython/jit/metainterp/optimizeopt/intbounds.py
b/rpython/jit/metainterp/optimizeopt/intbounds.py
--- a/rpython/jit/metainterp/optimizeopt/intbounds.py
+++ b/rpython/jit/metainterp/optimizeopt/intbounds.py
@@ -38,16 +38,6 @@
return n
-class IntBoundsCallbackArgs(object):
- def __init__(self, op, callback_func=None):
- self.op = op
- self.callback_func = callback_func
-
- def callback(self):
- if self.callback_func is not None:
- self.callback_func(self.op)
-
-
class OptIntBounds(Optimization):
"""Keeps track of the bounds placed on integers by guards and remove
redundant guards"""
@@ -58,8 +48,8 @@
def propagate_forward(self, op):
return dispatch_opt(self, op)
- def propagate_postprocess(self, op):
- return dispatch_postprocess(self, op)
+ def propagate_postprocess(self, op, oldop):
+ return dispatch_postprocess(self, op, oldop)
def propagate_bounds_backward(self, box):
# FIXME: This takes care of the instruction where box is the reuslt
@@ -75,7 +65,7 @@
def _optimize_guard_true_false_value(self, op):
return op
- def _postprocess_guard_true_false_value(self, op):
+ def _postprocess_guard_true_false_value(self, op, oldop):
if op.getarg(0).type == 'i':
self.propagate_bounds_backward(op.getarg(0))
@@ -98,7 +88,7 @@
return None
return op
- def postprocess_INT_OR_or_XOR(self, op):
+ def postprocess_INT_OR_or_XOR(self, op, oldop):
v1 = self.get_box_replacement(op.getarg(0))
b1 = self.getintbound(v1)
v2 = self.get_box_replacement(op.getarg(1))
@@ -118,7 +108,7 @@
def optimize_INT_AND(self, op):
return op
- def postprocess_INT_AND(self, op):
+ def postprocess_INT_AND(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
r = self.getintbound(op)
@@ -137,7 +127,7 @@
def optimize_INT_SUB(self, op):
return op
- def postprocess_INT_SUB(self, op):
+ def postprocess_INT_SUB(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
b = b1.sub_bound(b2)
@@ -184,7 +174,7 @@
return op
- def postprocess_INT_ADD(self, op):
+ def postprocess_INT_ADD(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
r = self.getintbound(op)
@@ -195,7 +185,7 @@
def optimize_INT_MUL(self, op):
return op
- def postprocess_INT_MUL(self, op):
+ def postprocess_INT_MUL(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
r = self.getintbound(op)
@@ -206,7 +196,7 @@
def optimize_INT_FLOORDIV(self, op):
return op
- def postprocess_INT_FLOORDIV(self, op):
+ def postprocess_INT_FLOORDIV(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
r = self.getintbound(op)
@@ -227,7 +217,7 @@
args=[arg1, arg2])
return op
- def postprocess_INT_MOD(self, op):
+ def postprocess_INT_MOD(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
known_nonneg = (b1.known_ge(IntBound(0, 0)) and
@@ -248,7 +238,7 @@
def optimize_INT_LSHIFT(self, op):
return op
- def postprocess_INT_LSHIFT(self, op):
+ def postprocess_INT_LSHIFT(self, op, oldop):
arg0 = self.get_box_replacement(op.getarg(0))
b1 = self.getintbound(arg0)
arg1 = self.get_box_replacement(op.getarg(1))
@@ -274,7 +264,7 @@
return None
return op
- def postprocess_INT_RSHIFT(self, op):
+ def postprocess_INT_RSHIFT(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
b = b1.rshift_bound(b2)
@@ -331,7 +321,7 @@
op = self.replace_op_with(op, rop.INT_ADD)
return op
- def postprocess_INT_ADD_OVF(self, op):
+ def postprocess_INT_ADD_OVF(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
resbound = b1.add_bound(b2)
@@ -351,7 +341,7 @@
op = self.replace_op_with(op, rop.INT_SUB)
return op
- def postprocess_INT_SUB_OVF(self, op):
+ def postprocess_INT_SUB_OVF(self, op, oldop):
arg0 = self.get_box_replacement(op.getarg(0))
arg1 = self.get_box_replacement(op.getarg(1))
b0 = self.getintbound(arg0)
@@ -368,7 +358,7 @@
op = self.replace_op_with(op, rop.INT_MUL)
return op
- def postprocess_INT_MUL_OVF(self, op):
+ def postprocess_INT_MUL_OVF(self, op, oldop):
b1 = self.getintbound(op.getarg(0))
b2 = self.getintbound(op.getarg(1))
resbound = b1.mul_bound(b2)
@@ -469,7 +459,7 @@
else:
return op
- def postprocess_INT_SIGNEXT(self, op):
+ def postprocess_INT_SIGNEXT(self, op, oldop):
numbits = op.getarg(1).getint() * 8
start = -(1 << (numbits - 1))
stop = 1 << (numbits - 1)
@@ -480,14 +470,14 @@
def optimize_ARRAYLEN_GC(self, op):
return op
- def postprocess_ARRAYLEN_GC(self, op):
+ def postprocess_ARRAYLEN_GC(self, op, oldop):
array = self.ensure_ptr_info_arg0(op)
self.optimizer.setintbound(op, array.getlenbound(None))
def optimize_STRLEN(self, op):
return op
- def postprocess_STRLEN(self, op):
+ def postprocess_STRLEN(self, op, oldop):
self.make_nonnull_str(op.getarg(0), vstring.mode_string)
array = self.getptrinfo(op.getarg(0))
self.optimizer.setintbound(op, array.getlenbound(vstring.mode_string))
@@ -495,7 +485,7 @@
def optimize_UNICODELEN(self, op):
return op
- def postprocess_UNICODELEN(self, op):
+ def postprocess_UNICODELEN(self, op, oldop):
self.make_nonnull_str(op.getarg(0), vstring.mode_unicode)
array = self.getptrinfo(op.getarg(0))
self.optimizer.setintbound(op, array.getlenbound(vstring.mode_unicode))
@@ -503,7 +493,7 @@
def optimize_STRGETITEM(self, op):
return op
- def postprocess_STRGETITEM(self, op):
+ def postprocess_STRGETITEM(self, op, oldop):
v1 = self.getintbound(op)
v2 = self.getptrinfo(op.getarg(0))
intbound = self.getintbound(op.getarg(1))
@@ -517,7 +507,7 @@
def optimize_GETFIELD_RAW_I(self, op):
return op
- def postprocess_GETFIELD_RAW_I(self, op):
+ def postprocess_GETFIELD_RAW_I(self, op, oldop):
descr = op.getdescr()
if descr.is_integer_bounded():
b1 = self.getintbound(op)
@@ -547,7 +537,7 @@
def optimize_GETARRAYITEM_RAW_I(self, op):
return op
- def postprocess_GETARRAYITEM_RAW_I(self, op):
+ def postprocess_GETARRAYITEM_RAW_I(self, op, oldop):
descr = op.getdescr()
if descr and descr.is_item_integer_bounded():
intbound = self.getintbound(op)
@@ -567,7 +557,7 @@
def optimize_UNICODEGETITEM(self, op):
return op
- def postprocess_UNICODEGETITEM(self, op):
+ def postprocess_UNICODEGETITEM(self, op, oldop):
b1 = self.getintbound(op)
b1.make_ge(IntLowerBound(0))
v2 = self.getptrinfo(op.getarg(0))
diff --git a/rpython/jit/metainterp/optimizeopt/optimizer.py
b/rpython/jit/metainterp/optimizeopt/optimizer.py
--- a/rpython/jit/metainterp/optimizeopt/optimizer.py
+++ b/rpython/jit/metainterp/optimizeopt/optimizer.py
@@ -272,7 +272,7 @@
def set_optimizations(self, optimizations):
if optimizations:
- self.first_optimization = optimizations[1]
+ self.first_optimization = optimizations[2]
for i in range(1, len(optimizations)):
optimizations[i - 1].next_optimization = optimizations[i]
optimizations[-1].next_optimization = self
@@ -538,12 +538,15 @@
op.set_forwarded(None)
def send_extra_operation(self, op):
- newop = self.optimizations[0].propagate_forward(op)
- if newop is None:
- return
- self.optimizations[0].last_emitted_operation = newop
- self.first_optimization.propagate_forward(newop)
- self.optimizations[0].propagate_postprocess(newop)
+ oldop = op
+ for optimization in self.optimizations[:2]:
+ op = optimization.propagate_forward(op)
+ if op is None:
+ return
+ optimization.last_emitted_operation = op
+ self.first_optimization.propagate_forward(op)
+ for optimization in reversed(self.optimizations[:2]):
+ optimization.propagate_postprocess(op, oldop)
def propagate_forward(self, op):
dispatch_opt(self, op)
diff --git a/rpython/jit/metainterp/optimizeopt/rewrite.py
b/rpython/jit/metainterp/optimizeopt/rewrite.py
--- a/rpython/jit/metainterp/optimizeopt/rewrite.py
+++ b/rpython/jit/metainterp/optimizeopt/rewrite.py
@@ -24,6 +24,9 @@
self.loop_invariant_results = {}
self.loop_invariant_producer = {}
+ def opt_default(self, op):
+ return op
+
def setup(self):
self.optimizer.optrewrite = self
@@ -36,7 +39,10 @@
if self.find_rewritable_bool(op):
return
- dispatch_opt(self, op)
+ return dispatch_opt(self, op)
+
+ def propagate_postprocess(self, op, oldop):
+ return dispatch_postprocess(self, op, oldop)
def try_boolinvers(self, op, targs):
oldop = self.get_pure_result(targs)
@@ -97,7 +103,7 @@
self.make_equal_to(op, op.getarg(1))
return
- self.emit_operation(op)
+ return op
def optimize_INT_OR(self, op):
b1 = self.getintbound(op.getarg(0))
@@ -107,7 +113,7 @@
elif b2.equal(0):
self.make_equal_to(op, op.getarg(0))
else:
- self.emit_operation(op)
+ return op
def optimize_INT_SUB(self, op):
arg1 = self.get_box_replacement(op.getarg(0))
@@ -118,20 +124,18 @@
self.make_equal_to(op, arg1)
elif b1.equal(0):
op = self.replace_op_with(op, rop.INT_NEG, args=[arg2])
- self.emit_operation(op)
+ return op
elif arg1.same_box(arg2):
self.make_constant_int(op, 0)
else:
- self.emit_operation(op)
- self.optimize_INT_SUB_callback(op)
+ return op
- def optimize_INT_SUB_callback(self, op):
+ def postprocess_INT_SUB(self, op, oldop):
self.optimizer.pure_reverse(op)
def optimize_INT_ADD(self, op):
if self.is_raw_ptr(op.getarg(0)) or self.is_raw_ptr(op.getarg(1)):
- self.emit_operation(op)
- return
+ return op
arg1 = self.get_box_replacement(op.getarg(0))
b1 = self.getintbound(arg1)
arg2 = self.get_box_replacement(op.getarg(1))
@@ -143,10 +147,9 @@
elif b2.equal(0):
self.make_equal_to(op, arg1)
else:
- self.emit_operation(op)
- self.optimize_INT_ADD_callback(op)
+ return op
- def optimize_INT_ADD_callback(self, op):
+ def postprocess_INT_ADD(self, op, oldop):
self.optimizer.pure_reverse(op)
def optimize_INT_MUL(self, op):
@@ -172,7 +175,7 @@
new_rhs = ConstInt(highest_bit(lh_info.getint()))
op = self.replace_op_with(op, rop.INT_LSHIFT,
args=[rhs, new_rhs])
break
- self.emit_operation(op)
+ return op
def optimize_UINT_FLOORDIV(self, op):
b2 = self.getintbound(op.getarg(1))
@@ -180,7 +183,7 @@
if b2.is_constant() and b2.getint() == 1:
self.make_equal_to(op, op.getarg(0))
else:
- self.emit_operation(op)
+ return op
def optimize_INT_LSHIFT(self, op):
b1 = self.getintbound(op.getarg(0))
@@ -191,7 +194,7 @@
elif b1.is_constant() and b1.getint() == 0:
self.make_constant_int(op, 0)
else:
- self.emit_operation(op)
+ return op
def optimize_INT_RSHIFT(self, op):
b1 = self.getintbound(op.getarg(0))
@@ -202,7 +205,7 @@
elif b1.is_constant() and b1.getint() == 0:
self.make_constant_int(op, 0)
else:
- self.emit_operation(op)
+ return op
def optimize_INT_XOR(self, op):
b1 = self.getintbound(op.getarg(0))
@@ -213,7 +216,7 @@
elif b2.equal(0):
self.make_equal_to(op, op.getarg(0))
else:
- self.emit_operation(op)
+ return op
def optimize_FLOAT_MUL(self, op):
arg1 = op.getarg(0)
@@ -231,12 +234,10 @@
return
elif v1.getfloat() == -1.0:
newop = self.replace_op_with(op, rop.FLOAT_NEG, args=[rhs])
- self.emit_operation(newop)
- return
- self.emit_operation(op)
- self.optimize_FLOAT_MUL_callback(op)
+ return newop
+ return op
- def optimize_FLOAT_MUL_callback(self, op):
+ def postprocess_FLOAT_MUL(self, op, oldop):
self.optimizer.pure_reverse(op)
def optimize_FLOAT_TRUEDIV(self, op):
@@ -258,16 +259,15 @@
c = ConstFloat(longlong.getfloatstorage(reciprocal))
newop = self.replace_op_with(op, rop.FLOAT_MUL,
args=[arg1, c])
- self.emit_operation(newop)
+ return newop
def optimize_FLOAT_NEG(self, op):
- self.emit_operation(op)
- self.optimize_FLOAT_NEG_callback(op)
+ return op
- def optimize_FLOAT_NEG_callback(self, op):
+ def postprocess_FLOAT_NEG(self, op, oldop):
self.optimizer.pure_reverse(op)
- def optimize_guard(self, op, constbox, emit_operation=True):
+ def optimize_guard(self, op, constbox):
box = op.getarg(0)
if box.type == 'i':
intbound = self.getintbound(box)
@@ -288,14 +288,7 @@
'was proven to always fail' % r)
return
- if emit_operation:
- self.emit_operation(op)
- self.optimize_guard_callback(op, box, constbox)
- else:
- self.optimize_guard_callback(op, box, constbox)
-
- def optimize_guard_callback(self, op, box, constbox):
- self.make_constant(box, constbox)
+ return op
def optimize_GUARD_ISNULL(self, op):
info = self.getptrinfo(op.getarg(0))
@@ -306,10 +299,9 @@
r = self.optimizer.metainterp_sd.logger_ops.repr_of_resop(op)
raise InvalidLoop('A GUARD_ISNULL (%s) was proven to always '
'fail' % r)
- self.emit_operation(op)
- self.optimize_GUARD_ISNULL_callback(op)
+ return op
- def optimize_GUARD_ISNULL_callback(self, op):
+ def postprocess_GUARD_ISNULL(self, op, oldop):
self.make_constant(op.getarg(0), self.optimizer.cpu.ts.CONST_NULL)
def optimize_GUARD_IS_OBJECT(self, op):
@@ -326,7 +318,7 @@
return
if info.is_precise():
raise InvalidLoop()
- self.emit_operation(op)
+ return op
def optimize_GUARD_GC_TYPE(self, op):
info = self.getptrinfo(op.getarg(0))
@@ -340,7 +332,7 @@
if info.get_descr().get_type_id() != op.getarg(1).getint():
raise InvalidLoop("wrong GC types passed around!")
return
- self.emit_operation(op)
+ return op
def _check_subclass(self, vtable1, vtable2):
# checks that vtable1 is a subclass of vtable2
@@ -374,7 +366,7 @@
if self._check_subclass(info.get_descr().get_vtable(),
op.getarg(1).getint()):
return
- self.emit_operation(op)
+ return op
def optimize_GUARD_NONNULL(self, op):
opinfo = self.getptrinfo(op.getarg(0))
@@ -385,10 +377,9 @@
r = self.optimizer.metainterp_sd.logger_ops.repr_of_resop(op)
raise InvalidLoop('A GUARD_NONNULL (%s) was proven to always '
'fail' % r)
- self.emit_operation(op)
- self.optimize_GUARD_NONNULL_callback(op)
+ return op
- def optimize_GUARD_NONNULL_callback(self, op):
+ def postprocess_GUARD_NONNULL(self, op, oldop):
self.make_nonnull(op.getarg(0))
self.getptrinfo(op.getarg(0)).mark_last_guard(self.optimizer)
@@ -409,7 +400,11 @@
return
constbox = op.getarg(1)
assert isinstance(constbox, Const)
- self.optimize_guard(op, constbox)
+ return self.optimize_guard(op, constbox)
+
+ def postprocess_GUARD_VALUE(self, op, oldop):
+ box = self.get_box_replacement(op.getarg(0))
+ self.make_constant(box, op.getarg(1))
def replace_guard_class_with_guard_value(self, op, info, old_guard_op):
if old_guard_op.opnum != rop.GUARD_NONNULL:
@@ -437,10 +432,18 @@
return op
def optimize_GUARD_TRUE(self, op):
- self.optimize_guard(op, CONST_1)
+ return self.optimize_guard(op, CONST_1)
+
+ def postprocess_GUARD_TRUE(self, op, oldop):
+ box = self.get_box_replacement(op.getarg(0))
+ self.make_constant(box, CONST_1)
def optimize_GUARD_FALSE(self, op):
- self.optimize_guard(op, CONST_0)
+ return self.optimize_guard(op, CONST_0)
+
+ def postprocess_GUARD_FALSE(self, op, oldop):
+ box = self.get_box_replacement(op.getarg(0))
+ self.make_constant(box, CONST_0)
def optimize_RECORD_EXACT_CLASS(self, op):
opinfo = self.getptrinfo(op.getarg(0))
@@ -483,17 +486,16 @@
# not put in short preambles guard_nonnull and guard_class
# on the same box.
self.optimizer.replace_guard(op, info)
- self.emit_operation(op)
- self.optimize_GUARD_CLASS_callback_1(op, expectedclassbox)
- return
- self.emit_operation(op)
- self.optimize_GUARD_CLASS_callback_2(op, expectedclassbox)
+ return op
+ return op
- def optimize_GUARD_CLASS_callback_1(self, op, expectedclassbox):
- self.make_constant_class(op.getarg(0), expectedclassbox, False)
-
- def optimize_GUARD_CLASS_callback_2(self, op, expectedclassbox):
- self.make_constant_class(op.getarg(0), expectedclassbox)
+ def postprocess_GUARD_CLASS(self, op, oldop):
+ expectedclassbox = op.getarg(1)
+ info = self.getptrinfo(op.getarg(0))
+ old_guard_op = info.get_last_guard(self.optimizer)
+ update_last_guard = not old_guard_op or isinstance(
+ old_guard_op.getdescr(), compile.ResumeAtPositionDescr)
+ self.make_constant_class(op.getarg(0), expectedclassbox,
update_last_guard)
def optimize_GUARD_NONNULL_CLASS(self, op):
info = self.getptrinfo(op.getarg(0))
@@ -501,7 +503,9 @@
r = self.optimizer.metainterp_sd.logger_ops.repr_of_resop(op)
raise InvalidLoop('A GUARD_NONNULL_CLASS (%s) was proven to '
'always fail' % r)
- self.optimize_GUARD_CLASS(op)
+ return self.optimize_GUARD_CLASS(op)
+
+ postprocess_GUARD_NONNULL_CLASS = postprocess_GUARD_CLASS
def optimize_CALL_LOOPINVARIANT_I(self, op):
arg = op.getarg(0)
@@ -521,16 +525,21 @@
# there is no reason to have a separate operation for this
newop = self.replace_op_with(op,
OpHelpers.call_for_descr(op.getdescr()))
- self.emit_operation(newop)
- self.optimize_CALL_LOOPINVARIANT_I_callback(newop, op, key)
+ return op
- def optimize_CALL_LOOPINVARIANT_I_callback(self, newop, op, key):
+ def postprocess_CALL_LOOPINVARIANT_I(self, op, oldop):
+ key = make_hashable_int(op.getarg(0).getint())
self.loop_invariant_producer[key] = self.optimizer.getlastop()
- self.loop_invariant_results[key] = op
+ self.loop_invariant_results[key] = oldop
+
optimize_CALL_LOOPINVARIANT_R = optimize_CALL_LOOPINVARIANT_I
optimize_CALL_LOOPINVARIANT_F = optimize_CALL_LOOPINVARIANT_I
optimize_CALL_LOOPINVARIANT_N = optimize_CALL_LOOPINVARIANT_I
+ postprocess_CALL_LOOPINVARIANT_R = postprocess_CALL_LOOPINVARIANT_I
+ postprocess_CALL_LOOPINVARIANT_F = postprocess_CALL_LOOPINVARIANT_I
+ postprocess_CALL_LOOPINVARIANT_N = postprocess_CALL_LOOPINVARIANT_I
+
def optimize_COND_CALL(self, op):
arg = op.getarg(0)
b = self.getintbound(arg)
@@ -540,7 +549,7 @@
return
opnum = OpHelpers.call_for_type(op.type)
op = op.copy_and_change(opnum, args=op.getarglist()[1:])
- self.emit_operation(op)
+ return op
def _optimize_nullness(self, op, box, expect_nonnull):
info = self.getnullness(box)
@@ -549,17 +558,17 @@
elif info == INFO_NULL:
self.make_constant_int(op, not expect_nonnull)
else:
- self.emit_operation(op)
+ return op
def optimize_INT_IS_TRUE(self, op):
if (not self.is_raw_ptr(op.getarg(0)) and
self.getintbound(op.getarg(0)).is_bool()):
self.make_equal_to(op, op.getarg(0))
return
- self._optimize_nullness(op, op.getarg(0), True)
+ return self._optimize_nullness(op, op.getarg(0), True)
def optimize_INT_IS_ZERO(self, op):
- self._optimize_nullness(op, op.getarg(0), False)
+ return self._optimize_nullness(op, op.getarg(0), False)
def _optimize_oois_ooisnot(self, op, expect_isnot, instance):
arg0 = self.get_box_replacement(op.getarg(0))
@@ -575,9 +584,9 @@
elif info1 and info1.is_virtual():
self.make_constant_int(op, expect_isnot)
elif info1 and info1.is_null():
- self._optimize_nullness(op, op.getarg(0), expect_isnot)
+ return self._optimize_nullness(op, op.getarg(0), expect_isnot)
elif info0 and info0.is_null():
- self._optimize_nullness(op, op.getarg(1), expect_isnot)
+ return self._optimize_nullness(op, op.getarg(1), expect_isnot)
elif arg0 is arg1:
self.make_constant_int(op, not expect_isnot)
else:
@@ -596,19 +605,19 @@
# class is different
self.make_constant_int(op, expect_isnot)
return
- self.emit_operation(op)
+ return op
def optimize_PTR_EQ(self, op):
- self._optimize_oois_ooisnot(op, False, False)
+ return self._optimize_oois_ooisnot(op, False, False)
def optimize_PTR_NE(self, op):
- self._optimize_oois_ooisnot(op, True, False)
+ return self._optimize_oois_ooisnot(op, True, False)
def optimize_INSTANCE_PTR_EQ(self, op):
- self._optimize_oois_ooisnot(op, False, True)
+ return self._optimize_oois_ooisnot(op, False, True)
def optimize_INSTANCE_PTR_NE(self, op):
- self._optimize_oois_ooisnot(op, True, True)
+ return self._optimize_oois_ooisnot(op, True, True)
def optimize_CALL_N(self, op):
# dispatch based on 'oopspecindex' to a method that handles
@@ -617,14 +626,13 @@
effectinfo = op.getdescr().get_extra_info()
oopspecindex = effectinfo.oopspecindex
if oopspecindex == EffectInfo.OS_ARRAYCOPY:
- if self._optimize_CALL_ARRAYCOPY(op):
- return
- self.emit_operation(op)
+ return self._optimize_CALL_ARRAYCOPY(op)
+ return op
def _optimize_CALL_ARRAYCOPY(self, op):
length = self.get_constant_box(op.getarg(5))
if length and length.getint() == 0:
- return True # 0-length arraycopy
+ return None # 0-length arraycopy
source_info = self.getptrinfo(op.getarg(1))
dest_info = self.getptrinfo(op.getarg(2))
@@ -640,7 +648,7 @@
dest_start = dest_start_box.getint()
arraydescr = extrainfo.write_descrs_arrays[0]
if arraydescr.is_array_of_structs():
- return False # not supported right now
+ return op # not supported right now
# XXX fish fish fish
for index in range(length.getint()):
@@ -666,9 +674,9 @@
ConstInt(index + dest_start),
val],
descr=arraydescr)
- self.emit_operation(newop)
- return True
- return False
+ self.optimizer.send_extra_operation(newop)
+ return None
+ return op
def optimize_CALL_PURE_I(self, op):
# this removes a CALL_PURE with all constant arguments.
@@ -678,7 +686,8 @@
self.make_constant(op, result)
self.last_emitted_operation = REMOVED
return
- self.emit_operation(op)
+ return op
+
optimize_CALL_PURE_R = optimize_CALL_PURE_I
optimize_CALL_PURE_F = optimize_CALL_PURE_I
optimize_CALL_PURE_N = optimize_CALL_PURE_I
@@ -688,7 +697,7 @@
# it was a CALL_PURE or a CALL_LOOPINVARIANT that was killed;
# so we also kill the following GUARD_NO_EXCEPTION
return
- self.emit_operation(op)
+ return op
def optimize_GUARD_FUTURE_CONDITION(self, op):
self.optimizer.notice_guard_future_condition(op)
@@ -710,15 +719,15 @@
if val & (val - 1) == 0 and val > 0: # val == 2**shift
op = self.replace_op_with(op, rop.INT_RSHIFT,
args = [op.getarg(0), ConstInt(highest_bit(val))])
- self.emit_operation(op)
+ return op
def optimize_CAST_PTR_TO_INT(self, op):
self.optimizer.pure_reverse(op)
- self.emit_operation(op)
+ return op
def optimize_CAST_INT_TO_PTR(self, op):
self.optimizer.pure_reverse(op)
- self.emit_operation(op)
+ return op
def optimize_SAME_AS_I(self, op):
self.make_equal_to(op, op.getarg(0))
@@ -726,5 +735,6 @@
optimize_SAME_AS_F = optimize_SAME_AS_I
dispatch_opt = make_dispatcher_method(OptRewrite, 'optimize_',
- default=OptRewrite.emit_operation)
+ default=OptRewrite.opt_default)
optimize_guards = _findall(OptRewrite, 'optimize_', 'GUARD')
+dispatch_postprocess = make_dispatcher_method(OptRewrite, 'postprocess_')
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
