[pypy-commit] pypy unrecursive-opt: Kill unnecessary oldop arg.

jerith noreply at buildbot.pypy.org
Mon Oct 12 11:31:12 CEST 2015


Author: Jeremy Thurgood <firxen at gmail.com>
Branch: unrecursive-opt
Changeset: r80126:0239a15d98b6
Date: 2015-10-12 11:13 +0200
http://bitbucket.org/pypy/pypy/changeset/0239a15d98b6/

Log:	Kill unnecessary oldop arg.

diff --git a/rpython/jit/metainterp/optimizeopt/earlyforce.py b/rpython/jit/metainterp/optimizeopt/earlyforce.py
--- a/rpython/jit/metainterp/optimizeopt/earlyforce.py
+++ b/rpython/jit/metainterp/optimizeopt/earlyforce.py
@@ -28,7 +28,7 @@
                 self.optimizer.force_box(arg, self)
         return self.emit(op)
 
-    def propagate_postprocess(self, op, oldop):
+    def propagate_postprocess(self, op):
         pass
 
     def setup(self):
diff --git a/rpython/jit/metainterp/optimizeopt/heap.py b/rpython/jit/metainterp/optimizeopt/heap.py
--- a/rpython/jit/metainterp/optimizeopt/heap.py
+++ b/rpython/jit/metainterp/optimizeopt/heap.py
@@ -502,7 +502,7 @@
         # return self.emit(op)
         return self.emit(op)
 
-    def postprocess_GETFIELD_GC_I(self, op, oldop):
+    def postprocess_GETFIELD_GC_I(self, op):
         # then remember the result of reading the field
         structinfo = self.ensure_ptr_info_arg0(op)
         cf = self.field_cache(op.getdescr())
@@ -562,7 +562,7 @@
         # return self.emit(op)
         return self.emit(op)
 
-    def postprocess_GETARRAYITEM_GC_I(self, op, oldop):
+    def postprocess_GETARRAYITEM_GC_I(self, op):
         # the remember the result of reading the array item
         arrayinfo = self.ensure_ptr_info_arg0(op)
         indexb = self.getintbound(op.getarg(1))
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
@@ -45,8 +45,8 @@
     def propagate_forward(self, op):
         return dispatch_opt(self, op)
 
-    def propagate_postprocess(self, op, oldop):
-        return dispatch_postprocess(self, op, oldop)
+    def propagate_postprocess(self, op):
+        return dispatch_postprocess(self, op)
 
     def propagate_bounds_backward(self, box):
         # FIXME: This takes care of the instruction where box is the reuslt
@@ -62,7 +62,7 @@
     def _optimize_guard_true_false_value(self, op):
         return self.emit(op)
 
-    def _postprocess_guard_true_false_value(self, op, oldop):
+    def _postprocess_guard_true_false_value(self, op):
         if op.getarg(0).type == 'i':
             self.propagate_bounds_backward(op.getarg(0))
 
@@ -85,7 +85,7 @@
             return None
         return self.emit(op)
 
-    def postprocess_INT_OR_or_XOR(self, op, oldop):
+    def postprocess_INT_OR_or_XOR(self, op):
         v1 = self.get_box_replacement(op.getarg(0))
         b1 = self.getintbound(v1)
         v2 = self.get_box_replacement(op.getarg(1))
@@ -105,7 +105,7 @@
     def optimize_INT_AND(self, op):
         return self.emit(op)
 
-    def postprocess_INT_AND(self, op, oldop):
+    def postprocess_INT_AND(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         r = self.getintbound(op)
@@ -124,7 +124,7 @@
     def optimize_INT_SUB(self, op):
         return self.emit(op)
 
-    def postprocess_INT_SUB(self, op, oldop):
+    def postprocess_INT_SUB(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         b = b1.sub_bound(b2)
@@ -171,7 +171,7 @@
 
         return self.emit(op)
 
-    def postprocess_INT_ADD(self, op, oldop):
+    def postprocess_INT_ADD(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         r = self.getintbound(op)
@@ -182,7 +182,7 @@
     def optimize_INT_MUL(self, op):
         return self.emit(op)
 
-    def postprocess_INT_MUL(self, op, oldop):
+    def postprocess_INT_MUL(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         r = self.getintbound(op)
@@ -193,7 +193,7 @@
     def optimize_INT_FLOORDIV(self, op):
         return self.emit(op)
 
-    def postprocess_INT_FLOORDIV(self, op, oldop):
+    def postprocess_INT_FLOORDIV(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         r = self.getintbound(op)
@@ -214,7 +214,7 @@
                                           args=[arg1, arg2])
         return self.emit(op)
 
-    def postprocess_INT_MOD(self, op, oldop):
+    def postprocess_INT_MOD(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         known_nonneg = (b1.known_ge(IntBound(0, 0)) and
@@ -235,7 +235,7 @@
     def optimize_INT_LSHIFT(self, op):
         return self.emit(op)
 
-    def postprocess_INT_LSHIFT(self, op, oldop):
+    def postprocess_INT_LSHIFT(self, op):
         arg0 = self.get_box_replacement(op.getarg(0))
         b1 = self.getintbound(arg0)
         arg1 = self.get_box_replacement(op.getarg(1))
@@ -261,7 +261,7 @@
             return None
         return self.emit(op)
 
-    def postprocess_INT_RSHIFT(self, op, oldop):
+    def postprocess_INT_RSHIFT(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         b = b1.rshift_bound(b2)
@@ -318,7 +318,7 @@
             op = self.replace_op_with(op, rop.INT_ADD)
         return self.emit(op)
 
-    def postprocess_INT_ADD_OVF(self, op, oldop):
+    def postprocess_INT_ADD_OVF(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         resbound = b1.add_bound(b2)
@@ -338,7 +338,7 @@
             op = self.replace_op_with(op, rop.INT_SUB)
         return self.emit(op)
 
-    def postprocess_INT_SUB_OVF(self, op, oldop):
+    def postprocess_INT_SUB_OVF(self, op):
         arg0 = self.get_box_replacement(op.getarg(0))
         arg1 = self.get_box_replacement(op.getarg(1))
         b0 = self.getintbound(arg0)
@@ -355,7 +355,7 @@
             op = self.replace_op_with(op, rop.INT_MUL)
         return self.emit(op)
 
-    def postprocess_INT_MUL_OVF(self, op, oldop):
+    def postprocess_INT_MUL_OVF(self, op):
         b1 = self.getintbound(op.getarg(0))
         b2 = self.getintbound(op.getarg(1))
         resbound = b1.mul_bound(b2)
@@ -456,7 +456,7 @@
         else:
             return self.emit(op)
 
-    def postprocess_INT_SIGNEXT(self, op, oldop):
+    def postprocess_INT_SIGNEXT(self, op):
         numbits = op.getarg(1).getint() * 8
         start = -(1 << (numbits - 1))
         stop = 1 << (numbits - 1)
@@ -467,14 +467,14 @@
     def optimize_ARRAYLEN_GC(self, op):
         return self.emit(op)
 
-    def postprocess_ARRAYLEN_GC(self, op, oldop):
+    def postprocess_ARRAYLEN_GC(self, op):
         array = self.ensure_ptr_info_arg0(op)
         self.optimizer.setintbound(op, array.getlenbound(None))
 
     def optimize_STRLEN(self, op):
         return self.emit(op)
 
-    def postprocess_STRLEN(self, op, oldop):
+    def postprocess_STRLEN(self, op):
         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))
@@ -482,7 +482,7 @@
     def optimize_UNICODELEN(self, op):
         return self.emit(op)
 
-    def postprocess_UNICODELEN(self, op, oldop):
+    def postprocess_UNICODELEN(self, op):
         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))
@@ -490,7 +490,7 @@
     def optimize_STRGETITEM(self, op):
         return self.emit(op)
 
-    def postprocess_STRGETITEM(self, op, oldop):
+    def postprocess_STRGETITEM(self, op):
         v1 = self.getintbound(op)
         v2 = self.getptrinfo(op.getarg(0))
         intbound = self.getintbound(op.getarg(1))
@@ -504,7 +504,7 @@
     def optimize_GETFIELD_RAW_I(self, op):
         return self.emit(op)
 
-    def postprocess_GETFIELD_RAW_I(self, op, oldop):
+    def postprocess_GETFIELD_RAW_I(self, op):
         descr = op.getdescr()
         if descr.is_integer_bounded():
             b1 = self.getintbound(op)
@@ -534,7 +534,7 @@
     def optimize_GETARRAYITEM_RAW_I(self, op):
         return self.emit(op)
 
-    def postprocess_GETARRAYITEM_RAW_I(self, op, oldop):
+    def postprocess_GETARRAYITEM_RAW_I(self, op):
         descr = op.getdescr()
         if descr and descr.is_item_integer_bounded():
             intbound = self.getintbound(op)
@@ -554,7 +554,7 @@
     def optimize_UNICODEGETITEM(self, op):
         return self.emit(op)
 
-    def postprocess_UNICODEGETITEM(self, op, oldop):
+    def postprocess_UNICODEGETITEM(self, op):
         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
@@ -43,8 +43,8 @@
         self.callback_func = callback_func
         self.callback_args = callback_args
 
-    def callback(self, oldop):
-        self.callback_func(self.op, oldop, *self.callback_args)
+    def callback(self):
+        self.callback_func(self.op, *self.callback_args)
 
 
 class Optimization(object):
@@ -564,7 +564,6 @@
     def send_extra_operation(self, op, opt=None):
         if opt is None:
             opt = self.first_optimization
-        oldop = op
         opt_results = []
         while opt is not None:
             opt_result = opt.propagate_forward(op)
@@ -575,7 +574,7 @@
             op = opt_result.op
             opt = opt.next_optimization
         for opt_result in reversed(opt_results):
-            opt_result.callback(oldop)
+            opt_result.callback()
 
     def propagate_forward(self, op):
         dispatch_opt(self, op)
diff --git a/rpython/jit/metainterp/optimizeopt/pure.py b/rpython/jit/metainterp/optimizeopt/pure.py
--- a/rpython/jit/metainterp/optimizeopt/pure.py
+++ b/rpython/jit/metainterp/optimizeopt/pure.py
@@ -73,8 +73,8 @@
     def propagate_forward(self, op):
         return dispatch_opt(self, op)
 
-    def propagate_postprocess(self, op, oldop):
-        dispatch_postprocess(self, op, oldop)
+    def propagate_postprocess(self, op):
+        dispatch_postprocess(self, op)
 
     def optimize_default(self, op):
         canfold = op.is_always_pure()
@@ -113,7 +113,7 @@
         # otherwise, the operation remains
         return self.emit(op, self.postprocess_default, save, nextop)
 
-    def postprocess_default(self, op, oldop, save, nextop):
+    def postprocess_default(self, op, save, nextop):
         # postprocessor for optimize_default, not default postprocessor
         if op.returns_bool_result():
             self.getintbound(op).make_bool()
@@ -166,7 +166,7 @@
         newop = self.optimizer.replace_op_with(op, opnum)
         return self.emit(newop, self.postprocess_call_pure)
 
-    def postprocess_call_pure(self, op, oldop):
+    def postprocess_call_pure(self, op):
         self.call_pure_positions.append(
             len(self.optimizer._newoperations) - 1)
 
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
@@ -38,8 +38,8 @@
 
         return dispatch_opt(self, op)
 
-    def propagate_postprocess(self, op, oldop):
-        return dispatch_postprocess(self, op, oldop)
+    def propagate_postprocess(self, op):
+        return dispatch_postprocess(self, op)
 
     def try_boolinvers(self, op, targs):
         oldop = self.get_pure_result(targs)
@@ -127,7 +127,7 @@
         else:
             return self.emit(op)
 
-    def postprocess_INT_SUB(self, op, oldop):
+    def postprocess_INT_SUB(self, op):
         self.optimizer.pure_reverse(op)
 
     def optimize_INT_ADD(self, op):
@@ -146,7 +146,7 @@
         else:
             return self.emit(op)
 
-    def postprocess_INT_ADD(self, op, oldop):
+    def postprocess_INT_ADD(self, op):
         self.optimizer.pure_reverse(op)
 
     def optimize_INT_MUL(self, op):
@@ -234,7 +234,7 @@
                     return self.emit(newop)
         return self.emit(op)
 
-    def postprocess_FLOAT_MUL(self, op, oldop):
+    def postprocess_FLOAT_MUL(self, op):
         self.optimizer.pure_reverse(op)
 
     def optimize_FLOAT_TRUEDIV(self, op):
@@ -261,7 +261,7 @@
     def optimize_FLOAT_NEG(self, op):
         return self.emit(op)
 
-    def postprocess_FLOAT_NEG(self, op, oldop):
+    def postprocess_FLOAT_NEG(self, op):
         self.optimizer.pure_reverse(op)
 
     def optimize_guard(self, op, constbox):
@@ -298,7 +298,7 @@
                                   'fail' % r)
         return self.emit(op)
 
-    def postprocess_GUARD_ISNULL(self, op, oldop):
+    def postprocess_GUARD_ISNULL(self, op):
         self.make_constant(op.getarg(0), self.optimizer.cpu.ts.CONST_NULL)
 
     def optimize_GUARD_IS_OBJECT(self, op):
@@ -376,7 +376,7 @@
                                   'fail' % r)
         return self.emit(op)
 
-    def postprocess_GUARD_NONNULL(self, op, oldop):
+    def postprocess_GUARD_NONNULL(self, op):
         self.make_nonnull(op.getarg(0))
         self.getptrinfo(op.getarg(0)).mark_last_guard(self.optimizer)
 
@@ -399,7 +399,7 @@
         assert isinstance(constbox, Const)
         return self.optimize_guard(op, constbox)
 
-    def postprocess_GUARD_VALUE(self, op, oldop):
+    def postprocess_GUARD_VALUE(self, op):
         box = self.get_box_replacement(op.getarg(0))
         self.make_constant(box, op.getarg(1))
 
@@ -431,14 +431,14 @@
     def optimize_GUARD_TRUE(self, op):
         return self.optimize_guard(op, CONST_1)
 
-    def postprocess_GUARD_TRUE(self, op, oldop):
+    def postprocess_GUARD_TRUE(self, op):
         box = self.get_box_replacement(op.getarg(0))
         self.make_constant(box, CONST_1)
 
     def optimize_GUARD_FALSE(self, op):
         return self.optimize_guard(op, CONST_0)
 
-    def postprocess_GUARD_FALSE(self, op, oldop):
+    def postprocess_GUARD_FALSE(self, op):
         box = self.get_box_replacement(op.getarg(0))
         self.make_constant(box, CONST_0)
 
@@ -486,7 +486,7 @@
                 return self.emit(op)
         return self.emit(op)
 
-    def postprocess_GUARD_CLASS(self, op, oldop):
+    def postprocess_GUARD_CLASS(self, op):
         expectedclassbox = op.getarg(1)
         info = self.getptrinfo(op.getarg(0))
         old_guard_op = info.get_last_guard(self.optimizer)
@@ -522,7 +522,7 @@
         # there is no reason to have a separate operation for this
         newop = self.replace_op_with(op,
                                      OpHelpers.call_for_descr(op.getdescr()))
-        return self.emit(op)
+        return self.emit(newop, self.postprocess_CALL_LOOPINVARIANT_I, op)
 
     def postprocess_CALL_LOOPINVARIANT_I(self, op, oldop):
         key = make_hashable_int(op.getarg(0).getint())
diff --git a/rpython/jit/metainterp/optimizeopt/virtualize.py b/rpython/jit/metainterp/optimizeopt/virtualize.py
--- a/rpython/jit/metainterp/optimizeopt/virtualize.py
+++ b/rpython/jit/metainterp/optimizeopt/virtualize.py
@@ -70,7 +70,7 @@
         self._finish_guard_op = self._last_guard_not_forced_2
         return self.emit(op)
 
-    def postprocess_FINISH(self, op, oldop):
+    def postprocess_FINISH(self, op):
         guard_op = self._finish_guard_op
         if guard_op is not None:
             guard_op = self.optimizer.store_final_boxes_in_guard(guard_op, [])
diff --git a/rpython/jit/metainterp/optimizeopt/vstring.py b/rpython/jit/metainterp/optimizeopt/vstring.py
--- a/rpython/jit/metainterp/optimizeopt/vstring.py
+++ b/rpython/jit/metainterp/optimizeopt/vstring.py
@@ -425,8 +425,8 @@
     def propagate_forward(self, op):
         return dispatch_opt(self, op)
 
-    def propagate_postprocess(self, op, oldop):
-        return dispatch_postprocess(self, op, oldop)
+    def propagate_postprocess(self, op):
+        return dispatch_postprocess(self, op)
 
     def make_vstring_plain(self, op, mode, length):
         vvalue = VStringPlainInfo(mode, True, length)
@@ -460,10 +460,10 @@
             self.make_nonnull_str(op, mode)
             return self.emit(op)
 
-    def postprocess_NEWSTR(self, op, oldop):
+    def postprocess_NEWSTR(self, op):
         self.pure_from_args(mode_string.STRLEN, [op], op.getarg(0))
 
-    def postprocess_NEWUNICODE(self, op, oldop):
+    def postprocess_NEWUNICODE(self, op):
         self.pure_from_args(mode_unicode.STRLEN, [op], op.getarg(0))
 
     def optimize_STRSETITEM(self, op):


More information about the pypy-commit mailing list